ERC-2470 — Singleton Factory

Back to Infrastructure & Patterns

ERC-2470: Singleton Factory

ERC-2470 deploys a single permissionless SingletonFactory at a deterministic address (0xce0042B868300000d44A59004Da54A005ffdcf9f) so that anyone can use the same factory across all EVM chains for CREATE2-style deployment. The factory was deployed via Nick's-method (a one-shot ECDSA signature with a deterministically generated public key whose private key nobody knows).

Why Such a Niche Standard Exists

Different chains have different CREATE2-deployer-contract addresses. Without a universal factory, the same contract bytecode deployed to Polygon, Arbitrum, and Mainnet would have different addresses. ERC-2470 standardises one factory address across chains so contracts deployed via that factory get the same address everywhere.

Neo Equivalent

Neo doesn't have this fragmentation problem: a contract's script hash is Hash160(deployer || script || name). If the same deployer redeploys the same NEF + manifest on testnet and mainnet, the script hashes are identical. No singleton factory required.

For multi-chain projects (e.g. a deploy bot deploying the same contract to multiple Neo networks), the script hash is the same on each.

Live on Neo TestNet

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

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0x625c19cbd8d0b5cf03bd9996b67a824c14448012	0xbb6e02b4…51651a
Neo C# (nccs)	0x602d11eca4ebba2799b076fdbba251d1d9eaedf5	0x10eda9be…7f8832

Cross-implementation invocations match on claimDeployer / _deploy, deployCount, getDeployer. Source pairs under docs/standards-mirror/deployments/erc-2470/.

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

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

    /// Bytes32 salt + arbitrary initcode -> deterministic deploy.
    function deploy(bytes memory initCode, bytes32 salt) external returns (address addr) {
        assembly {
            addr := create2(0, add(initCode, 0x20), mload(initCode), salt)
        }
        emit Deployed(addr, salt);
    }
}

// User-side prediction
contract MyDeployer {
    address constant FACTORY = 0xce0042B868300000d44A59004Da54A005ffdcf9f;

    function predict(bytes memory initCode, bytes32 salt) public pure returns (address) {
        bytes32 hash = keccak256(abi.encodePacked(
            bytes1(0xff), FACTORY, salt, keccak256(initCode)
        ));
        return address(uint160(uint256(hash)));
    }
}

using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;

namespace R3E.Examples;

/// <summary>
/// On Neo, every deployer is "the singleton factory" — there's nothing to standardise.
///
/// To deploy a contract with a deterministic script hash:
///   ContractManagement.Deploy(nef, manifest, data);
///
/// To predict the script hash before deploy:
///   var hash = (UInt160)CryptoLib.Ripemd160(CryptoLib.Sha256(
///       deployerHash.ToArray().Concat(nefScript).Concat(manifestName)));
///
/// Multi-chain identity is automatic: same deployer + same NEF + same manifest
/// name => same script hash on testnet and mainnet.
/// </summary>
public static class DeploymentNotes { /* this whole concept is a no-op on Neo */ }

Why This EIP Exists Only on Ethereum

CREATE2's address depends on address(deployer). Each chain assigns the deployer a different address, so the same deployment transaction creates a different address on each chain. ERC-2470 deployed a single factory at the same address across all EVMs as a workaround.

Neo doesn't have this problem: addresses are derived from the deployment script, not from a chain-specific deployer address. Same script + same name + same deployer hash = same address everywhere.