Minimal proxy (clone) pattern in Blockchain / Solidity - Mini Project: Build & Apply

Minimal Proxy (Clone) Pattern in Solidity

📖 Scenario: You are building a smart contract system on Ethereum. You want to create many lightweight copies (clones) of a main contract to save gas and storage. This is useful when you have a standard contract logic but want separate instances for different users.

🎯 Goal: Build a minimal proxy contract that clones a main contract using the EIP-1167 minimal proxy pattern. You will create the main contract, then write a factory contract that deploys clones pointing to the main contract.

📋 What You'll Learn

Create a main contract called LogicContract with a public uint variable value and a function setValue(uint _value) to update it.

Create a factory contract called CloneFactory with a function createClone(address target) that deploys a minimal proxy clone of target using assembly.

Store the address of the deployed clone in a public variable lastClone.

Write a function getCloneValue() in the factory that calls value() on the last clone and returns it.

Print the address of the last clone and the value stored in it.

💡 Why This Matters

🌍 Real World

Minimal proxy clones save gas and storage on Ethereum by reusing contract logic. This pattern is widely used in DeFi and NFT projects to deploy many instances cheaply.

💼 Career

Understanding minimal proxies is important for blockchain developers working on scalable smart contract systems and optimizing gas costs.

1

Create the main contract with a value variable and setter

Create a contract called LogicContract with a public uint variable named value. Add a public function setValue(uint _value) that sets value to _value.

Blockchain / Solidity

// Your code here

Hint

Think of LogicContract as the main blueprint. It has a number value and a way to change it.

2

Add the clone factory contract with createClone function

Create a contract called CloneFactory. Inside it, declare a public address variable lastClone. Add a public function createClone(address target) that deploys a minimal proxy clone of target using assembly and stores the clone address in lastClone. Use the standard EIP-1167 bytecode pattern for the clone.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint public value;

    function setValue(uint _value) public {
        value = _value;
    }
}

contract CloneFactory {
    address public lastClone;

    // Your code here
}

Hint

Use assembly to write the minimal proxy bytecode. The pattern is fixed and uses the create opcode.

3

Add a function to get the value from the last clone

In the CloneFactory contract, add a public view function getCloneValue() that calls the value() function on the lastClone address using staticcall and returns the uint value.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint public value;

    function setValue(uint _value) public {
        value = _value;
    }
}

contract CloneFactory {
    address public lastClone;

    function createClone(address target) public returns (address result) {
        bytes20 targetBytes = bytes20(target);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3)
            mstore(add(clone, 0x14), shl(0x60, targetBytes))
            mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf3)
            result := create(0, clone, 0x37)
        }
        lastClone = result;
    }

    function getCloneValue() public view returns (uint val) {
        // Your code here
    }
}

Hint

Use staticcall to safely call the value() function on the clone without changing state.

4

Print the last clone address and its stored value

Add a public view function printLastCloneInfo() in CloneFactory that returns the lastClone address and the uint value from getCloneValue(). Then write a simple script or test that deploys LogicContract, deploys CloneFactory, creates a clone of LogicContract, sets the value on the clone to 42, and prints the clone address and value.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint public value;

    function setValue(uint _value) public {
        value = _value;
    }
}

contract CloneFactory {
    address public lastClone;

    function createClone(address target) public returns (address result) {
        bytes20 targetBytes = bytes20(target);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3)
            mstore(add(clone, 0x14), shl(0x60, targetBytes))
            mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf3)
            result := create(0, clone, 0x37)
        }
        lastClone = result;
    }

    function getCloneValue() public view returns (uint val) {
        (bool success, bytes memory data) = lastClone.staticcall(abi.encodeWithSignature("value()"));
        require(success, "Call failed");
        val = abi.decode(data, (uint));
    }

    function printLastCloneInfo() public view returns (address cloneAddress, uint cloneValue) {
        // Your code here
    }
}

// Script or test code to deploy and interact
// Your code here

Hint

Return both the clone address and its stored value. The test script simulates deployment and interaction.

Practice

1. What is the main purpose of the Minimal proxy (clone) pattern in blockchain development?

easy

A. To replace the original contract with a new one

B. To increase the size of deployed contracts

C. To create cheap copies of contracts by forwarding calls

D. To store large amounts of data on-chain

Solution

1. Step 1: Understand the pattern's goal

   The minimal proxy pattern is designed to save gas and storage by creating lightweight copies of a contract.

2. Step 2: Identify the correct purpose

   It achieves this by forwarding calls to the original contract instead of duplicating all code.

3. Final Answer:

   To create cheap copies of contracts by forwarding calls -> Option C

4. Quick Check:

   Minimal proxy pattern = cheap contract copies [OK]

Hint: Minimal proxy means cheap clones forwarding calls [OK]

Common Mistakes:

• Thinking it increases contract size
• Confusing it with data storage methods
• Assuming it replaces original contracts

2. Which of the following Solidity code snippets correctly declares a minimal proxy clone using the create opcode?

easy

A. address clone = create(0, bytecode, bytecode.length);

B. address clone = new Contract();

C. address clone = create2(0, bytecode, bytecode.length);

D. address clone = delegatecall(bytecode);

Solution

1. Step 1: Identify the correct opcode for minimal proxy creation

   The create opcode is used to deploy a new contract with given bytecode.

2. Step 2: Match the syntax

   The syntax create(0, bytecode, bytecode.length) correctly uses create with zero value and bytecode parameters.

3. Final Answer:

   address clone = create(0, bytecode, bytecode.length); -> Option A

4. Quick Check:

   Minimal proxy uses create opcode like address clone = create(0, bytecode, bytecode.length); [OK]

Hint: Minimal proxy uses create, not new or delegatecall [OK]

Common Mistakes:

• Using new keyword which deploys full contract
• Confusing create2 with create
• Using delegatecall which does not deploy

3. Given the following Solidity code snippet for deploying a minimal proxy clone, what will be the output of clone.owner() if the original contract's owner is set to address 0x1234...?

address clone = Clones.clone(original);
// original.owner() returns 0x1234...
// clone forwards calls to original

medium

A. 0x1234... (same owner as original)

B. 0x0000... (zero address)

C. Revert error due to missing owner variable

D. Address of the clone contract

Solution

1. Step 1: Understand call forwarding in minimal proxy

   The clone forwards calls to the original contract, but storage is separate, so state variables like owner are not shared.

2. Step 2: Determine owner value returned

   Since owner() reads from the clone's storage which is uninitialized, it returns 0x0000... (zero address).

3. Final Answer:

   0x0000... (zero address) -> Option B

4. Quick Check:

   Clone forwards calls but has separate storage, owner = zero address [OK]

Hint: Clone has separate storage, owner defaults to zero [OK]

Common Mistakes:

• Assuming clone shares storage with original
• Expecting original owner to be returned
• Thinking clone address is returned

4. Identify the error in this minimal proxy deployment code snippet:

function clone(address implementation) external returns (address instance) {
    bytes20 targetBytes = bytes20(implementation);
    assembly {
        let clone_code := mload(0x40)
        mstore(clone_code, 0x3d602d80600a3d3981f3)
        mstore(add(clone_code, 0x14), targetBytes)
        instance := create(0, clone_code, 0x37)
    }
    require(instance != address(0), "Create failed");
}

medium

A. No error, code is correct

B. Missing delegatecall opcode in assembly

C. Using bytes20 instead of bytes32 for target address

D. Incorrect length passed to create (0x37 instead of 0x2d)

Solution

1. Step 1: Check the length parameter for create

   The minimal proxy bytecode length is typically 0x2d (45 bytes), but 0x37 (55 bytes) is passed incorrectly.

2. Step 2: Understand impact of wrong length

   Passing wrong length causes deployment of invalid bytecode, leading to failure or unexpected behavior.

3. Final Answer:

   Incorrect length passed to create (0x37 instead of 0x2d) -> Option D

4. Quick Check:

   Create length must match bytecode size [OK]

Hint: Check create length matches bytecode size [OK]

Common Mistakes:

• Ignoring bytecode length mismatch
• Confusing bytes20 and bytes32 usage
• Assuming delegatecall needed in deployment

5. You want to deploy 1000 instances of a contract cheaply using the minimal proxy pattern. Which approach best reduces gas and storage costs while allowing each clone to have its own owner?

hard

A. Use minimal proxies forwarding to one implementation and store owner in each clone's storage

B. Deploy 1000 full contracts separately with unique owners

C. Use minimal proxies forwarding to one implementation and store owner in the implementation contract

D. Deploy one contract and share the same owner for all clones

Solution

1. Step 1: Understand minimal proxy benefits

   Minimal proxies save gas by sharing code but have separate storage for each clone.

2. Step 2: Assign unique owners per clone

   Storing owner in each clone's storage allows unique ownership while sharing logic.

3. Step 3: Evaluate options

   Use minimal proxies forwarding to one implementation and store owner in each clone's storage uses minimal proxies with per-clone storage, reducing gas and allowing unique owners.

4. Final Answer:

   Use minimal proxies forwarding to one implementation and store owner in each clone's storage -> Option A

5. Quick Check:

   Minimal proxy + per-clone storage = cheap unique owners [OK]

Hint: Store owner in clone storage, share code via proxy [OK]

Common Mistakes:

• Storing owner only in implementation (shared state)
• Deploying full contracts wastes gas
• Sharing one owner for all clones