Factory pattern in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Factory pattern

Start

↓

Call Factory

↓

Factory creates new contract

↓

Return new contract address

↓

Use new contract

↓

End

The factory pattern creates new contracts on demand and returns their addresses for use.

Execution Sample

Blockchain / Solidity

contract SimpleContract {
    uint public value;
    constructor(uint _value) { value = _value; }
}

contract Factory {
    SimpleContract[] public contracts;
    function create(uint _value) public {
        SimpleContract c = new SimpleContract(_value);
        contracts.push(c);
    }
}

This code shows a factory contract creating new SimpleContract instances with a value.

Execution Table

Step	Action	Input	New Contract Created?	Contracts Array Length	Output
1	Call Factory.create	value=10	Yes	1	Address of new SimpleContract #1
2	Call Factory.create	value=20	Yes	2	Address of new SimpleContract #2
3	Call Factory.create	value=30	Yes	3	Address of new SimpleContract #3
4	Read contracts array length	-	-	3	3
5	Access SimpleContract #2 value	-	-	-	20
6	Stop	-	-	-	No more actions

💡 Execution stops after creating contracts and reading their data.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
contracts.length	0	1	2	3	3
SimpleContract #1.value	-	10	10	10	10
SimpleContract #2.value	-	-	20	20	20
SimpleContract #3.value	-	-	-	30	30

Key Moments - 3 Insights

Why does the factory store contract addresses instead of contract objects?

In blockchain, contracts are separate deployed entities. The factory stores their addresses to interact with them later, as shown in execution_table rows 1-3 where new addresses are added.

How does the factory create a new contract instance?

The factory uses the 'new' keyword to deploy a new contract on the blockchain, as seen in execution_table steps 1-3 where each call creates a new contract.

What happens if we try to access a contract that was not created?

Accessing a non-existent contract would fail or return an error because its address is not stored, as the contracts array length limits access, shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the contracts array length after the second contract creation?

A 1

B 2

C 3

D 0

💡 Hint

Check the 'Contracts Array Length' column at step 2 in the execution_table.

At which step does the factory create the third SimpleContract?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look for 'New Contract Created?' column in execution_table where it says 'Yes' for the third time.

If the factory did not store the new contract addresses, what would change in the variable_tracker?

A SimpleContract values would be accessible

B contracts.length would increase

C contracts.length would remain 0

D No contracts would be created

💡 Hint

Refer to the 'contracts.length' row in variable_tracker and think what happens if addresses are not stored.

Concept Snapshot

Factory Pattern in Blockchain:
- Factory contract creates new contracts using 'new'
- Stores addresses of created contracts in an array
- Allows tracking and interacting with multiple contracts
- Useful for deploying many similar contracts easily
- Access contracts by their stored addresses

Full Transcript

The factory pattern in blockchain programming helps create new contracts dynamically. The factory contract has a function that deploys new contracts using the 'new' keyword and stores their addresses in an array. Each time the factory creates a contract, the array length increases. Later, you can access each contract's data by its address stored in the array. This pattern is useful when you want to manage many similar contracts from one place. The execution table shows each step of creating contracts and reading their values. The variable tracker shows how the contracts array and contract values change after each creation. Key points include understanding why addresses are stored, how contracts are created, and what happens if you try to access contracts that do not exist.

Practice

1.

What is the main purpose of the Factory pattern in blockchain development?

easy

A. To create multiple similar contracts easily and manage their addresses

B. To encrypt data on the blockchain

C. To mine new blocks faster

D. To validate transactions off-chain

Solution

1. Step 1: Understand the Factory pattern role

   The Factory pattern is used to create many similar contracts efficiently.

2. Step 2: Identify its key feature

   It also stores the addresses of these created contracts for easy access later.

3. Final Answer:

   To create multiple similar contracts easily and manage their addresses -> Option A

4. Quick Check:

   Factory pattern = create and manage contracts [OK]

Hint: Factory pattern creates and tracks contracts easily [OK]

Common Mistakes:

• Confusing factory with encryption or mining
• Thinking factory validates transactions
• Assuming factory works off-chain

2.

Which of the following is the correct Solidity syntax to deploy a new contract inside a factory contract?

function create() public returns (address) {
    address newContract = new ?();
    return newContract;
}

easy

A. ContractName

B. contractname

C. new ContractName()

D. ContractName()

Solution

1. Step 1: Recall Solidity contract creation syntax

   To create a new contract instance, use new ContractName().

2. Step 2: Match syntax with code snippet

   The placeholder new ?() expects the contract name without 'new' repeated.

3. Final Answer:

   ContractName -> Option A

4. Quick Check:

   Use 'new ContractName()' but only 'ContractName' inside parentheses [OK]

Hint: Use contract name only inside new keyword parentheses [OK]

Common Mistakes:

• Writing 'new' twice
• Using lowercase contract names
• Omitting parentheses

3.

Consider this Solidity factory contract snippet:

contract Simple {
    uint public value;
    constructor(uint _value) {
        value = _value;
    }
}

contract Factory {
    Simple[] public simples;
    function createSimple(uint _val) public {
        Simple s = new Simple(_val);
        simples.push(s);
    }
    function getValue(uint index) public view returns (uint) {
        return simples[index].value();
    }
}

What will getValue(0) return after calling createSimple(42) once?

medium

A. Address of the contract

B. 0

C. 42

D. Compilation error

Solution

1. Step 1: Understand contract creation and storage

   Calling createSimple(42) creates a new Simple contract with value = 42 and stores it in simples array.

2. Step 2: Check what getValue(0) returns

   It returns the value of the first Simple contract, which is 42.

3. Final Answer:

   42 -> Option C

4. Quick Check:

   Created contract value = 42 [OK]

Hint: Created contract stores value; getValue returns it [OK]

Common Mistakes:

• Confusing contract address with stored value
• Assuming default zero value
• Thinking it returns array length

4.

Identify the error in this factory contract code snippet:

contract Product {
    uint public id;
    constructor(uint _id) {
        id = _id;
    }
}

contract ProductFactory {
    Product[] public products;
    function createProduct(uint _id) public {
        Product p = Product(_id);
        products.push(p);
    }
}

medium

A. Array products should be a mapping

B. Missing new keyword when creating Product

C. Constructor should not have parameters

D. Function createProduct must be view

Solution

1. Step 1: Check contract instantiation syntax

   In Solidity, to create a new contract instance, you must use the new keyword.

2. Step 2: Identify the missing keyword

   The line Product p = Product(_id); misses new, it should be Product p = new Product(_id);.

3. Final Answer:

   Missing new keyword when creating Product -> Option B

4. Quick Check:

   Contract creation requires 'new' keyword [OK]

Hint: Always use 'new' to create contracts in Solidity [OK]

Common Mistakes:

• Forgetting 'new' keyword
• Changing array to mapping unnecessarily
• Marking create function as view incorrectly

5.

You want to build a factory contract that creates multiple token contracts with different initial supplies and keeps track of them. Which approach best applies the factory pattern to save gas and organize your project?

hard

A. Use a single token contract and change its supply dynamically for each user

B. Deploy all token contracts manually and hardcode their addresses in the factory

C. Create token contracts but do not store their addresses anywhere

D. Create each token contract separately and store their addresses in an array inside the factory

Solution

1. Step 1: Understand factory pattern benefits

   The factory pattern helps create many similar contracts and keeps track of them efficiently.

2. Step 2: Evaluate options for managing multiple tokens

   Creating each token contract inside the factory and storing their addresses allows easy management and gas savings.

3. Step 3: Reject other options

   Hardcoding addresses is inflexible, using one contract for all tokens breaks isolation, and not storing addresses loses track.

4. Final Answer:

   Create each token contract separately and store their addresses in an array inside the factory -> Option D

5. Quick Check:

   Factory creates and tracks contracts for organization [OK]

Hint: Factory creates and stores contracts for easy management [OK]

Common Mistakes:

• Hardcoding addresses reduces flexibility
• Using one contract for all tokens causes conflicts
• Not storing addresses loses track of contracts