Checks-Effects-Interactions pattern in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Checks-Effects-Interactions pattern

Start Function Call

↓

Perform Checks

↓

Update State (Effects)

↓

Interact with External Contracts

↓

End Function

This pattern ensures safety by first checking conditions, then updating contract state, and finally interacting with other contracts.

Execution Sample

Blockchain / Solidity

function withdraw(uint amount) public {
  require(balances[msg.sender] >= amount);
  balances[msg.sender] -= amount;
  (bool success, ) = msg.sender.call{value: amount}("");
  require(success);
}

Withdraw function that first checks balance, then updates it, and finally sends Ether to the user.

Execution Table

Step	Action	Evaluation/State	Result/Effect
1	Check if user balance >= amount	balances[msg.sender] = 100, amount = 50	True, continue
2	Subtract amount from user balance	balances[msg.sender] = 100 - 50	balances[msg.sender] = 50
3	Send Ether to user (external call)	Call msg.sender with 50 Ether	Ether sent successfully
4	Require success of external call	success = true	Function completes successfully

💡 Execution stops after successful external call and state update

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
balances[msg.sender]	100	100	50	50	50
amount	50	50	50	50	50
success	undefined	undefined	undefined	true	true

Key Moments - 3 Insights

Why do we update the balance before sending Ether?

Updating the balance first (Step 2) prevents reentrancy attacks by ensuring the contract state is correct before external calls (Step 3). See execution_table rows 2 and 3.

What happens if the check fails?

If the check in Step 1 fails, the function stops immediately and no state changes or external calls happen, preventing unsafe operations.

Why do we require success after the external call?

Requiring success (Step 4) ensures the external call did not fail silently, so the function only completes if Ether was sent properly.

Visual Quiz - 3 Questions

Look at the execution_table, what is the balance after Step 2?

A 100

B 0

C 50

D Undefined

💡 Hint

Check the 'balances[msg.sender]' value in variable_tracker after Step 2

At which step does the contract interact with an external address?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for external calls

If the check in Step 1 fails, what happens next?

A State updates and external call still happen

B Function stops immediately, no changes

C Only external call happens

D Balance is set to zero

💡 Hint

Refer to key_moments about what happens if the check fails

Concept Snapshot

Checks-Effects-Interactions pattern:
1. Checks: Verify conditions first (e.g., require statements).
2. Effects: Update contract state variables next.
3. Interactions: Finally, call external contracts.
This order prevents reentrancy and ensures safe state changes.

Full Transcript

The Checks-Effects-Interactions pattern is a safety method in blockchain programming. First, the contract checks if conditions are met, like if the user has enough balance. Then, it updates its own state, such as subtracting the withdrawn amount. Lastly, it interacts with external contracts, for example sending Ether. This order helps avoid security problems like reentrancy attacks. In the example, the function withdraw checks the balance, updates it, then sends Ether. If any check fails, the function stops immediately. This pattern is important for writing safe smart contracts.