Ethereum: Reentrancy Guard and CEI – Understanding the Role of Both Modifiers

Ethereum modifiers are a key element in smart contract development. Two specific modifiers that play an important role in ensuring the integrity and security of contracts are the ReentrancyGuard (RGC) modifier and the Check Effect Interactions (CEI) pattern. In this article, we will delve into the importance of these two modifiers and illustrate their use with examples.

What is the Reentrancy Guard modifier?

The ReentrancyGuard modifier is a built-in Ethereum decorator that prevents a contract from repeatedly calling itself or another function when the same instruction is called. This ensures that the contract cannot run in an infinite loop, which can lead to serious security vulnerabilities and even failures.

Do I need to use the Reentrancy Guard modifier if my contract follows the CEI model?

No, you don't necessarily need to use the ReentrancyGuard modifier if your contract follows the Verification Effect Interaction (CEI) model. The CEI model is a more advanced and elegant way to ensure that the effects of interacting with a function do not have side effects on other functions in the same contract.

In fact, the CEI model offers more comprehensive contract integrity and security guarantees that often outweigh the need for the ReentrancyGuard modifier. The CEI model includes several important principles, such as:

• 
  No calls: A contract cannot call itself.

• 
  No recursive calls: A contract cannot recursively call another function.

• 
  No shared state: There is no shared state between functions.

What is Verification Effect Interaction (CEI)?

Verification Effect Interactions (CEI) is an interaction model that allows you to create complex contracts that greatly affect other functions. CEI provides a way to express these interactions in a more elegant and understandable way, while ensuring the integrity and security of the contract.

Example: Using the ReentrancyGuard Modifier

Let's look at an example of a simple contract that follows the CEI model:

pragma robustness ^0.8.0;
contract Simple Contract {
// The ReentrancyGuard modifier is not used here.
function doSomething() public {
// This function cannot call itself.
Require(!isSelf(), "Reentrancy");
// Call another function that interacts with this contract.
FunctionInteraction interaction = new FunctionInteraction();
interaction.doSomethingElse();
}
function isSelf() internal view return (bool) {
return msg.sender != address(0);
}
}

In this example, we define a simple contract "SimpleContract" with two functions: "doSomething()" and "isSelf()". The "doSomething()" function calls another function "doSomethingElse()" that interacts with the contract. However, since we did not use the ReentrancyGuard modifier, we need to install it manually:

pragma robustness ^0.8.0;
contract SimpleContract {
// Use the ReentrancyGuard modifier.
function doSomething() public {
Require(!isSelf(), "Reentrancy");
// Call another function that interacts with this contract.
FunctionInteraction interaction = new FunctionInteraction();
interaction.doSomethingElse();
// It is now safe to call doSomething again because we have prevented reentrancy.
}
function isSelf() internal view return (bool) {
return msg.sender != address(0);
}
}

Conclusion

In summary, while the ReentrancyGuard modifier can be used to avoid infinite loops in a contract that conforms to the CEI model, it is not always necessary.