Factory pattern in Blockchain / Solidity - Mini Project: Build & Apply

Factory Pattern in Blockchain Smart Contracts

📖 Scenario: You are working on a blockchain project where you need to create multiple simple contracts that represent digital assets. Instead of deploying each contract manually, you will build a factory contract that can create new asset contracts on demand.

🎯 Goal: Build a factory contract in Solidity that can create new asset contracts. Each asset contract will store a name and an owner address. The factory will keep track of all created asset contracts.

📋 What You'll Learn

Create a simple asset contract with a name and owner state variables.

Create a factory contract that can deploy new asset contracts.

Store the addresses of all created asset contracts in the factory.

Provide a function to get the total number of created asset contracts.

💡 Why This Matters

🌍 Real World

Factory patterns are used in blockchain to efficiently deploy many similar contracts, such as tokens, NFTs, or digital assets, without manual deployment each time.

💼 Career

Understanding factory patterns is important for blockchain developers to write scalable and maintainable smart contracts that manage multiple contract instances.

1

Create the Asset Contract

Write a Solidity contract called Asset with two public state variables: string public name and address public owner. Add a constructor that takes string memory _name and address _owner as parameters and sets the state variables accordingly.

Blockchain / Solidity

// Your code here

Hint

Think of the asset contract as a simple container that stores a name and an owner address. The constructor sets these values when the contract is created.

2

Create the Factory Contract with Storage

Write a Solidity contract called AssetFactory. Inside it, create a public dynamic array of addresses called assets to store the addresses of created asset contracts.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Asset {
    string public name;
    address public owner;

    constructor(string memory _name, address _owner) {
        name = _name;
        owner = _owner;
    }
}

contract AssetFactory {
    // Your code here
}

Hint

The factory contract will keep track of all asset contracts it creates by storing their addresses in an array.

3

Add Function to Create New Asset Contracts

Inside the AssetFactory contract, add a public function called createAsset that takes a string memory _name parameter. This function should deploy a new Asset contract with _name and msg.sender as the owner. Then, add the new asset's address to the assets array.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Asset {
    string public name;
    address public owner;

    constructor(string memory _name, address _owner) {
        name = _name;
        owner = _owner;
    }
}

contract AssetFactory {
    address[] public assets;

    // Add createAsset function here
}

Hint

Use the new keyword to deploy a new contract inside another contract. Store the new contract's address in the array.

4

Add Function to Get Total Number of Assets and Test

Add a public view function called getAssetsCount in the AssetFactory contract that returns the number of created asset contracts. Then, write a simple test by calling createAsset twice with names "Gold" and "Silver", and print the result of getAssetsCount().

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Asset {
    string public name;
    address public owner;

    constructor(string memory _name, address _owner) {
        name = _name;
        owner = _owner;
    }
}

contract AssetFactory {
    address[] public assets;

    function createAsset(string memory _name) public {
        Asset newAsset = new Asset(_name, msg.sender);
        assets.push(address(newAsset));
    }

    // Add getAssetsCount function here
    // Then test by creating two assets and printing the count
}

Hint

The length of the assets array tells how many asset contracts have been created. Solidity contracts do not print, so you return values to check.

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