Creating contracts on blockchains that work with the Ethereum Virtual Machine (EVM) involves the use of special instructions called opcodes. Among these instructions: “CREATE” “CREATE2” “CREATE3” While the first two are actual opcodes, is a useful library that acts similarly. This guide will give you a quick overview of what each one does and why they matter. “create3” Leveraging the “create” Opcode The opcode is the most commonly used contract creation opcode. When contracts are deployed from scripts or other development environments, the opcode is the low-level instruction executed by the EVM to deploy and generate a contract address. create create Use-case: Creating new contracts within a contract dynamically. More cost-effective for deploying multiple contracts. When the address predictability is not a requirement. Leveraging the “create2” Opcode A fixed prefix, which is always . 0xFF The sender’s address ensures the contract is tied to a specific creator. A chosen salt value adds uniqueness to the contract address. The bytecode contains the code of the new contract to be deployed. By combining these parameters, computes a deterministic address for the new contract, which remains the same even as the blockchain evolves. CREATE2 Use-case: Ensuring a deterministic and predictable address for a new contract. Useful in state channels, contract wallets, and off-chain interactions. Offers an added layer of security by checking for existing contracts before deployment. Leveraging the “create3” Opcode is similar to but without including the contract on the address derivation formula. It can be used to generate deterministic contract addresses that aren’t tied to a specific contract code. CREATE3 CREATE2 initCode is a way to use and in combination such that bytecode no longer affects the deployment address. is more expensive than or (Fixed extra cost of ~55k gas). CREATE3 CREATE CREATE2 CREATE3 CREATE CREATE2 //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

/**
  @title A library for deploying contracts EIP-3171 style.
  @author Agustin Aguilar <aa@horizon.io>
*/
library Create3 {
  error ErrorCreatingProxy();
  error ErrorCreatingContract();
  error TargetAlreadyExists();

  /**
    @notice The bytecode for a contract that proxies the creation of another contract
    @dev If this code is deployed using CREATE2 it can be used to decouple `creationCode` from the child contract address

  0x67363d3d37363d34f03d5260086018f3:
      0x00  0x67  0x67XXXXXXXXXXXXXXXX  PUSH8 bytecode  0x363d3d37363d34f0
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 0x363d3d37363d34f0
      0x02  0x52  0x52                  MSTORE
      0x03  0x60  0x6008                PUSH1 08        8
      0x04  0x60  0x6018                PUSH1 18        24 8
      0x05  0xf3  0xf3                  RETURN

  0x363d3d37363d34f0:
      0x00  0x36  0x36                  CALLDATASIZE    cds
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x02  0x3d  0x3d                  RETURNDATASIZE  0 0 cds
      0x03  0x37  0x37                  CALLDATACOPY
      0x04  0x36  0x36                  CALLDATASIZE    cds
      0x05  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x06  0x34  0x34                  CALLVALUE       val 0 cds
      0x07  0xf0  0xf0                  CREATE          addr
  */
  
  bytes internal constant PROXY_CHILD_BYTECODE = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";

  //                        KECCAK256_PROXY_CHILD_BYTECODE = keccak256(PROXY_CHILD_BYTECODE);
  bytes32 internal constant KECCAK256_PROXY_CHILD_BYTECODE = 0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;

  /**
    @notice Returns the size of the code on a given address
    @param _addr Address that may or may not contain code
    @return size of the code on the given `_addr`
  */
  function codeSize(address _addr) internal view returns (uint256 size) {
    assembly { size := extcodesize(_addr) }
  }

  /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @return addr of the deployed contract, reverts on error
  */
  function create3(bytes32 _salt, bytes memory _creationCode) internal returns (address addr) {
    return create3(_salt, _creationCode, 0);
  }

  /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @param _value In WEI of ETH to be forwarded to child contract
    @return addr of the deployed contract, reverts on error
  */
  function create3(bytes32 _salt, bytes memory _creationCode, uint256 _value) internal returns (address addr) {
    // Creation code
    bytes memory creationCode = PROXY_CHILD_BYTECODE;

    // Get target final address
    addr = addressOf(_salt);
    if (codeSize(addr) != 0) revert TargetAlreadyExists();

    // Create CREATE2 proxy
    address proxy; assembly { proxy := create2(0, add(creationCode, 32), mload(creationCode), _salt)}
    if (proxy == address(0)) revert ErrorCreatingProxy();

    // Call proxy with final init code
    (bool success,) = proxy.call{ value: _value }(_creationCode);
    if (!success || codeSize(addr) == 0) revert ErrorCreatingContract();
  }

  /**
    @notice Computes the resulting address of a contract deployed using address(this) and the given `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @return addr of the deployed contract, reverts on error

    @dev The address creation formula is: keccak256(rlp([keccak256(0xff ++ address(this) ++ _salt ++ keccak256(childBytecode))[12:], 0x01]))
  */
  function addressOf(bytes32 _salt) internal view returns (address) {
    address proxy = address(
      uint160(
        uint256(
          keccak256(
            abi.encodePacked(
              hex'ff',
              address(this),
              _salt,
              KECCAK256_PROXY_CHILD_BYTECODE
            )
          )
        )
      )
    );

    return address(
      uint160(
        uint256(
          keccak256(
            abi.encodePacked(
              hex"d6_94",
              proxy,
              hex"01"
            )
          )
        )
      )
    );
  }
}

contract Child {
  function hola() external view returns (string memory) {
    return "mundo";
  }
}

contract Deployer {
  function deployChild() external {
    Create3.create3(keccak256(bytes("<my salt>")), type(Child).creationCode);
  }
}

contract Child2 {
  uint256 meaningOfLife;
  address owner;
  
  constructor(uint256 _meaning, address _owner) {
    meaningOfLife = _meaning;
    owner = _owner;
  }
}

contract Deployer2 {
  function deployChild() external {
    Create3.create3(
      keccak256(bytes("<my salt>")), 
      abi.encodePacked(
        type(Child).creationCode,
        abi.encode(
          42,
          msg.sender
        )
      )
    );
  }
} Features: Deterministic contract address based on msg.sender + salt. The same contract addresses different networks. EVM Supports any chain with support for . EVM-compatible CREATE2 Payable contract creation (forwarded to child contract) , Constructors supported. Use case: When the goal is to deploy your contracts to the same addresses on multiple blockchains, fewer factors affecting deployment addresses make it easier to achieve such a goal. So in this sense, is better to use than . CREATE3 CREATE2 Conclusion “ ,” “ ”, and “ ” are essential tools for anyone working with Ethereum contracts. Each one offers a different way to deploy contracts, with “ ” being straightforward, “ ” providing predictable contract addresses, and “ ” offering multi-chain compatibility through a library approach. Create create2 create3 create create2 create3 For hands-on details, check out: Basic Contract Deployment: Create1 Gist Predictable Contract Address Creation: Create2 Gist Consistent Multi-Chain Deployment: Create3 Gist For more on Ethereum development and insights, visit and . Connect with me on , , and . smart-contracts-developer.com solichain.com Twitter LinkedIn GitHub Also published . here

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Transient Storage: Ethereum's Game-Changing Feature

Why Intent-Centric Is Blockchain's Next Big Thing

Explore More on My Website

Read My Stories

Follow Me 

Too Long; Didn't Read

CTA: Download the FREE AI Productivity Shift report

Ethereum Virtual Machines: Your Guide to create, create2 and create3

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

The Exciting Road to Solidity 1.0.0

Essential Web3 calls

Create2: A Tale of Two Optcodes

(1/100) Crypto Countdown: Golem

05/03/2018: Biggest Stories in the Cryptosphere

The Exciting Road to Solidity 1.0.0

Essential Web3 calls

Create2: A Tale of Two Optcodes

(1/100) Crypto Countdown: Golem

05/03/2018: Biggest Stories in the Cryptosphere

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps