Can smart contracts deploy other smart contracts?

Yes, smart contracts can deploy other smart contracts. This is a powerful capability in blockchain technology, especially on platforms such as Ethereum that support smart contracts.

On Ethereum, smart contracts are written in Solidity, which enables the creation of new contracts. This capability allows a smart contract to function as a factory contract, dynamically generating and deploying other contracts. This is highly useful in various blockchain applications, such as in decentralized finance (DeFi) projects, creating unique assets or tokens, and managing complex logic and state within applications.

For instance, consider a decentralized voting system where each new voting event may require a separate smart contract to handle and store the voting logic and data. In this case, the main contract (which we can call a 'factory' contract) can generate code for each individual voting event contract. Whenever a new voting event is created, the main contract can deploy a new contract instance, each with its own independent storage and logic, without interference.

solidity
contract VotingFactory {
    address[] public deployedVotings;

    function createVoting(string memory _question) public {
        address newVoting = address(new Voting(_question));
        deployedVotings.push(newVoting);
    }

    function getDeployedVotings() public view returns (address[] memory) {
        return deployedVotings;
    }
}

contract Voting {
    string public question;
    mapping(address => bool) public votes;

    constructor(string memory _question) public {
        question = _question;
    }

    function vote(bool _vote) public {
        votes[msg.sender] = _vote;
    }

    function getVote(address voter) public view returns (bool) {
        return votes[voter];
    }
}

In this example, the VotingFactory contract can deploy new Voting contract instances, each used to handle a specific voting question. This allows each voting activity to have its own independent environment and storage space, with new votes dynamically created and managed.

This pattern enhances the flexibility and scalability of blockchain applications, enabling developers to build more complex and dynamic systems.