Create New Contract from within another contract of the same type in Solidity

Question

How can I create multiple contracts of Contract X using the new key word. I am getting an error that says cannot create instance of the same contract type. Is there a way around it ...

I would like to create a chain of contracts of the same type that point to each other.

Answer 1

For a contract to be able to create another contract, it needs the bytecode of the contract that is to be created. When a product creates a new product, that new product has to have the byte code of product as well and so on. The bytecode of products would be infinitly large.

You could create a factory contract, which contains the logic for creating new contracts, like this:

pragma solidity ^0.4.22;

contract Factory{
    function createNewProduct(Product _reference) public returns (Product) {
        Product p = new Product(_reference, this);
        return p;
    }
}

contract Product {
    Factory public factory;
    Product public reference;

    function Product(Product _reference, Factory _factory){
        reference = _reference;
        factory = _factory;
    }

    function haveFactoryCreateProductWithReferenceToThis() public {
        emit ProductCreated(factory.createNewProduct(this));
    }

    event ProductCreated(Product indexed product);
}

To deploy, first create the factory, then create a product (X) with reference "0x0". After that, you can create new products using the function haveFactoryCreateProductWithReferenceToThis

Answer 2

Circular creation.

The following is an example of creating a circular group of items.

In this example you would:

• create a new Factory
• check factory.head.next == factory.head
• call factory.add(factory.head)
• check factory.head.next is a new Item
• check factory.head.next.next == factory.head

Code:

pragma solidity ^0.4.22;

contract Item {
    Item public next;
    address owner;

    constructor(Item _next) public {
        owner = msg.sender;
        if (_next == Item(0)) {
            next = this;
        } else {
            next = _next;
        }
    }

    function addNew(Item item) public {
        require(msg.sender == owner);
        next = item;
    }
}

contract Factory {
    Item public head;

    constructor() public {
        head = new Item(Item(0));
    }

    function add(Item _to) public {
        Item link = _to.next();
        Item next = new Item(link);
        _to.addNew(next);
    }
}

Answer 3

Self Replication / Cloning using Assembly:

Of course you can if you really want to!

Make sure to read holiman's gist if you want to understand the assembly.

pragma solidity ^0.4.22;

// @mickys - based on https://gist.github.com/holiman/069de8d056a531575d2b786df3345665 
contract Replicator {

  address public parent;

  function replicate() public returns(address) {
      address childAddress = clone(address(this));
      Replicator child = Replicator(childAddress);
      child.setParent(address(this));
      return child;
  }

  function setParent(address addr) public {
      parent = addr;
  }

  function clone(address a) public returns(address)  {
    address retval;
    assembly{
        mstore(0x0, or (0x5880730000000000000000000000000000000000000000803b80938091923cF3 ,mul(a,0x1000000000000000000)))
        retval := create(0,0, 32)
    }
    return retval;
 }
}

Cheers!

Answer 4

Please try this:

   struct Project {
        string name;
        uint256 funds;
        uint256 available;
        address project;
        bool active;
    }

    mapping(address => Project) projects;
    address[] projectAddresses;

    function createProject(string name, uint amount) public {
        StandardToken token = new ProjectToken(name, amount);
        projectAddresses.push(token);
        projects[token] = Project(name, amount, amount, token, true);
    }