ERC-1014 — Skinny CREATE2

Back to Infrastructure & Patterns

EIP-1014: Deterministic Deployment via CREATE2

CREATE2(value, salt, code) deploys a contract at a deterministic address derived from (deployer, salt, codehash). Use cases: counterfactual deployment (you know the address before deploy), state channels, factory patterns, vanity addresses.

Address Formula

address = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:]

Neo Equivalent

Neo's ContractManagement.Deploy(nef, manifest, data) produces a script hash that's deterministic in the bytecode and the deployer's identity — same property, simpler formula.

scriptHash = Hash160(deployer || nef.script || manifest.name)

The deployer can pre-compute the script hash before deploy and use it in counterfactual flows. The Neo C# tab shows a factory pattern.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xc267a2eaa32edae5ac95d484a69e77653fe10b0e	(reused — see 0xc267a2eaa32edae5ac95d484a69e77653fe10b0e)
Neo C# (nccs)	0x462113ca40c8a41597165ccbeada2e70e57764f8	(reused — see 0x462113ca40c8a41597165ccbeada2e70e57764f8)

Cross-implementation invocations match on deployCount. Source pairs under docs/standards-mirror/deployments/erc-1014/.

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

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

    function deploy(bytes32 salt, bytes memory bytecode)
        external returns (address addr)
    {
        assembly {
            addr := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "deploy failed");
        emit Deployed(addr, salt);
    }

    function predict(bytes32 salt, bytes memory bytecode)
        external view returns (address)
    {
        bytes32 hash = keccak256(abi.encodePacked(
            bytes1(0xff), address(this), salt, keccak256(bytecode)
        ));
        return address(uint160(uint256(hash)));
    }
}

using System;
using System.ComponentModel;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("DeterministicFactory")]
[ContractPermission("*", "*")]
public class DeterministicFactory : SmartContract
{
    [DisplayName("Deployed")]
    public static event Action<UInt160, ByteString> OnDeployed;

    /// <summary>
    /// Deploy a contract. The resulting script hash is deterministic in
    /// (caller, nef.script, manifest.name) — predictable before the call.
    /// </summary>
    public static UInt160 Deploy(ByteString nef, string manifest, object data)
    {
        var contract = ContractManagement.Deploy(nef, manifest, data);
        OnDeployed(contract.Hash, nef);
        return contract.Hash;
    }

    /// <summary>
    /// Predict the script hash of a contract that hasn't been deployed yet,
    /// for use in counterfactual flows.
    /// </summary>
    public static UInt160 Predict(UInt160 deployer, ByteString nefScript, string manifestName)
    {
        var preimage = ((ByteString)deployer.ToArray())
            .Concat(nefScript)
            .Concat((ByteString)System.Text.Encoding.UTF8.GetBytes(manifestName));
        return (UInt160)CryptoLib.Ripemd160(CryptoLib.Sha256(preimage));
    }
}

What's Already Free

Neo doesn't need a separate "skinny CREATE2 EIP" because deterministic deployment is the only deployment mode. The script hash is the contract address; deployment yields it. There's no CREATE (sequential, nonce-based) for it to be a "skinny" alternative to.