Factory pattern in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity factory contract?

Consider this Solidity factory contract that creates simple storage contracts. What will be the value of storedData in the newly created contract after deployment?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleStorage {
    uint public storedData;
    constructor(uint initVal) {
        storedData = initVal;
    }
}

contract StorageFactory {
    SimpleStorage[] public storages;

    function createStorage(uint _initVal) public {
        SimpleStorage s = new SimpleStorage(_initVal);
        storages.push(s);
    }

    function getLastStoredData() public view returns (uint) {
        return storages[storages.length - 1].storedData();
    }
}

A The value passed to createStorage function

B The default value of uint (which is 1)

C 0

D It will revert with an error

💡 Hint

Look at how the SimpleStorage contract is created and initialized.

The factory creates a new SimpleStorage contract passing _initVal to its constructor. This sets storedData to that value.

🧠 Conceptual

intermediate

Why use a factory pattern in blockchain smart contracts?

Which of the following is the main reason to use a factory pattern in blockchain smart contracts?

A To reduce gas costs by storing all logic in one contract

B To automatically upgrade all contracts without redeployment

C To create multiple instances of a contract with different states easily

D To prevent any contract from being created on the blockchain

💡 Hint

Think about how factories help manage many contracts.

Factory contracts allow deploying many instances of a contract, each with its own state, making it easier to manage and create multiple contracts dynamically.

🔧 Debug

advanced

Identify the error in this factory contract code

What error will this Solidity factory contract produce when calling createStorage?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleStorage {
    uint public storedData;
    constructor(uint initVal) {
        storedData = initVal;
    }
}

contract StorageFactory {
    SimpleStorage[] public storages;

    function createStorage(uint _initVal) public {
        SimpleStorage s = SimpleStorage(_initVal);
        storages.push(s);
    }
}

A SyntaxError: Missing semicolon

B TypeError: Explicit constructor call is not allowed

C No error, works fine

D Runtime error: Out of gas

💡 Hint

Check how the new contract instance is created.

The line SimpleStorage s = SimpleStorage(_initVal); tries to call the constructor like a function, which is not allowed. The correct way is to use new SimpleStorage(_initVal);.

📝 Syntax

advanced

Which option correctly creates a new contract instance in a factory?

Given the contract Child with a constructor that takes a uint, which option correctly creates a new Child instance inside a factory contract?

Blockchain / Solidity

pragma solidity ^0.8.0;

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

contract Factory {
    Child[] public children;

    function createChild(uint _val) public {
        // Which line is correct here?
    }
}

A Child c = new Child(_val); children.push(c);

B Child c = Child(_val); children.push(c);

C Child c = Child.new(_val); children.push(c);

D Child c = new Child; children.push(c);

💡 Hint

Remember the syntax for creating new contract instances in Solidity.

The correct syntax to create a new contract instance is new ContractName(constructorArgs). Option A uses this correctly.

🚀 Application

expert

How many child contracts are created after these calls?

Given the following factory contract, how many Child contracts exist after these calls?

Calls made in order:

1. createChild(10)
2. createChild(20)
3. createChild(30)
4. deleteChild(1)

Blockchain / Solidity

pragma solidity ^0.8.0;

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

contract Factory {
    Child[] public children;

    function createChild(uint _val) public {
        Child c = new Child(_val);
        children.push(c);
    }

    function deleteChild(uint index) public {
        require(index < children.length, "Index out of range");
        delete children[index];
    }

    function getChildrenCount() public view returns (uint) {
        return children.length;
    }
}

A 0

B 2

C 1

D 3

💡 Hint

Deleting an element from an array in Solidity does not reduce its length.

The delete keyword resets the element at the index to its default value but does not remove it from the array or reduce the array length. So, the array length remains 3.