Diamond pattern (EIP-2535) in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Diamond pattern (EIP-2535)

Start: Deploy Diamond Contract

↓

Add Facets (Modules)

↓

Map Functions to Facets

↓

Call Function

↓

Diamond Delegatecall to Facet

↓

Execute Facet Logic

↓

Return Result

↓

End

The Diamond pattern deploys a main contract (Diamond) that delegates calls to multiple smaller contracts (Facets) based on function selectors.

Execution Sample

Blockchain / Solidity

contract Diamond {
  mapping(bytes4 => address) facets;
  fallback() external {
    address facet = facets[msg.sig];
    (bool success, ) = facet.delegatecall(msg.data);
    require(success, "Delegatecall failed");
  }
}

This code shows how the Diamond contract delegates calls to the correct facet using the function signature.

Execution Table

Step	Action	Input	Facet Selected	Delegatecall Result	Output
1	Receive call	functionA()	Lookup facets['functionA()']	facetA address found	Proceed
2	Delegatecall	Call facetA.functionA()	facetA	Execute facetA logic	Return result from facetA
3	Receive call	functionB()	Lookup facets['functionB()']	facetB address found	Proceed
4	Delegatecall	Call facetB.functionB()	facetB	Execute facetB logic	Return result from facetB
5	Receive call	functionX()	Lookup facets['functionX()']	No facet found	Revert call
6	Exit	No valid facet	None	Call reverted	Error returned

💡 Execution stops when no facet matches the function selector, causing a revert.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
facets	{}	{'functionA()': facetA}	{'functionA()': facetA, 'functionB()': facetB}	{'functionA()': facetA, 'functionB()': facetB}	{'functionA()': facetA, 'functionB()': facetB}
msg.sig	N/A	functionA()	functionB()	functionX()	functionX()
facet	null	facetA	facetB	null	null

Key Moments - 3 Insights

Why does the Diamond contract use delegatecall instead of a normal call?

Because delegatecall runs the facet's code in the Diamond's storage context, preserving state and allowing modular upgrades. See execution_table steps 2 and 4 where delegatecall executes facet logic.

What happens if a function selector is not found in the facets mapping?

The call reverts because no facet handles that function. This is shown in execution_table step 5 and 6 where no facet is found and the call reverts.

How does the Diamond pattern help with contract upgrades?

It allows adding, replacing, or removing facets without redeploying the whole contract, by updating the facets mapping. This modularity is implied in variable_tracker where facets mapping changes over time.

Visual Quiz - 3 Questions

Look at the execution_table, what is the facet selected at Step 3 when functionB() is called?

A facetA

B null

C facetB

D No facet found

💡 Hint

Check the 'Facet Selected' column at Step 3 in the execution_table.

At which step does the call revert due to no facet found?

A Step 4

B Step 5

C Step 2

D Step 1

💡 Hint

Look for 'No facet found' in the 'Delegatecall Result' column in the execution_table.

If a new facet is added for functionX(), how would the variable 'facets' change after Step 5?

A It would include 'functionX()' mapped to the new facet

B It would remove 'functionB()'

C It would stay the same

D It would become empty

💡 Hint

Refer to variable_tracker showing how facets mapping updates when new functions are added.

Concept Snapshot

Diamond pattern (EIP-2535) allows a single contract to delegate calls to multiple smaller contracts called facets.
Uses a mapping from function selectors to facet addresses.
Calls are forwarded using delegatecall to preserve storage.
Enables modular upgrades by adding/replacing facets.
If no facet matches, the call reverts.
Common in blockchain for flexible contract design.

Full Transcript

The Diamond pattern (EIP-2535) is a way to build smart contracts that can be split into smaller parts called facets. The main contract, called the Diamond, receives calls and looks up which facet should handle the function based on the function signature. It then uses delegatecall to run the facet's code but keeps the Diamond's storage. This allows the contract to be upgraded by adding or changing facets without redeploying everything. If a function is called that no facet handles, the call will revert and return an error. The execution table shows how calls are routed step-by-step, and the variable tracker shows how the facets mapping changes as new facets are added. This pattern helps developers create flexible and upgradeable contracts on the blockchain.