[Ethereum] Passing constructor arguments to the CREATE assembly instruction in solidity

assemblyconstructorcreatesolidity

I have a contract which deploys other contracts by bytecode:

contract DeployContract {
    function deploy(bytes calldata _bytecode) external returns(address addr) {

        bytes memory bytecode = abi.encode(_bytecode, msg.sender);
        assembly {
            addr := create(0, add(bytecode, 0x20), mload(bytecode))
            if iszero(extcodesize(addr)) {
                revert(0, 0)
            }
        }
    }
}

I want to deploy contracts which take an address as argument in their constructor. Appending the address to the bytecode as above does not work. How do I pass the constructor parameter?

Best Answer

This worked for CREATE2. Maybe it also works on CREATE?

abi.encodePacked(bytecode, abi.encode(arg1, arg2))

Example (CREATE2)

pragma solidity ^0.5.11;

contract Wallet {
    address public owner;
    uint public foo;

    constructor(address _owner, uint _foo) public {
        owner = _owner;
        foo = _foo;
    }
}

contract Factory {
    event Deployed(address addr, uint256 salt);

    function getCreationBytecode(address _owner, uint _foo) public pure returns (bytes memory) {
        bytes memory bytecode = type(Wallet).creationCode;

        return abi.encodePacked(bytecode, abi.encode(_owner, _foo));
    }

    // NOTE: call this function with bytecode from getCreationByteCode and a random salt
    function deploy(bytes memory bytecode, uint _salt) public {
        address addr;
        assembly {
            addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)

            if iszero(extcodesize(addr)) {
                revert(0, 0)
            }
        }

        emit Deployed(addr, _salt);
    }
}

Related Solutions

[Ethereum] Passing constructor arguments while deploying contract from byte code

If you look at Web3's documentation, you can get the full deployment bytecode with:

var bytecodeWithParam = MyContract.new.getData(
    param1,
    param2,
    { data: compiledByteCode });

It is this bytecodeWithParam that you paste into the "Byte Code" field. If you look at it in detail, you will see param1 and param2 32-byte packed at the end.

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

I changed your smart contract implementation with this smart contract.

I put notes just so you'd know your errors.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// NOTE: Import IERC20 contract
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// NOTE: You must to implement IERC20 for override ERC20 methods!
contract NewToken is IERC20 {

  string public constant name = "NewToken";
  string public constant symbol = "NTKN";
  uint8 public constant decimals = 18;
  uint256 totalSupply_ = 10000000000000000000000000; 

  mapping(address => uint256) public balances;
  mapping(address => mapping (address => uint256)) allowed;

  // NOTE: I removed the events because it already defined into IERC20
  
  constructor() { 
    balances[msg.sender] = totalSupply_;
  }

  function totalSupply() public override view returns (uint256) {
    return totalSupply_;
  }

  // NOTE: You must to change signature function adding address parameter
  function balanceOf(address _address) public override view returns(uint256) {
    return balances[_address];
  }

  function transfer(address to, uint256 value) public override returns (bool) {
      require(value <= balances[msg.sender]);
      balances[msg.sender] = balances[msg.sender]-value;
      balances[to] = balances[to]+value;
      // NOTE: The event is called  Transfer not 'transfer'
      emit Transfer(msg.sender, to, value);
      return true;
  }

  function approve(address spender, uint256 value) public override returns (bool) {
      allowed[msg.sender][spender] = value;
      emit Approval(msg.sender, spender, value);
      return true;
  }

  function allowance(address owner, address spender) public override view returns (uint) {
      return allowed[owner][spender];
  }

  function transferFrom(address from, address to, uint256 value) public override returns (bool) {
      require(value <= balances[from]);
      require(value <= allowed[from][msg.sender]);

      balances[from] = balances[from]-value;
      allowed[from][msg.sender] = allowed[from][msg.sender]+value;
      balances[to] = balances[to]+value;
      emit Transfer(from, to, value);
      return true;
  }
}

Best Answer

Related Solutions

[Ethereum] Passing constructor arguments while deploying contract from byte code

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

Related Topic