create2-patterns

# CREATE2 Deterministic Deployment Patterns ## Address Calculation CREATE2 address is determined by four inputs: ``` address = keccak256(0xff ++ deployer ++ salt ++ keccak256(initCode))[12:] ``` ```solidity function computeAddress(bytes32 salt, bytes32 initCodeHash, address deployer) internal pure returns (address) { return address(uint160(uint256(keccak256(abi.encodePacked( bytes1(0xff), deployer, salt, initCodeHash ))))); } ``` ## Basic CREATE2 Factory ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; contract Create2Factory { event Deployed(address indexed addr, bytes32 indexed salt); function deploy(bytes32 salt, bytes memory creationCode) external payable returns (address deployed) { assembly { deployed := create2(callvalue(), add(creationCode, 0x20), mload(creationCode), salt) } require(deployed != address(0), "CREATE2: deployment failed"); emit Deployed(deployed, salt); } function computeAddress(bytes32 salt, bytes memory creationCode) external view returns (address) { bytes32 hash = keccak256(abi.encodePacked( bytes1(0xff), address(this), salt, keccak256(creationCode) )); return address(uint160(uint256(hash))); } } ``` ## Salt Selection Strategies ```solidity // Simple: use deployer address + nonce bytes32 salt = keccak256(abi.encode(msg.sender, nonce)); // Access-controlled: only specific deployer can use this salt bytes32 salt = keccak256(abi.encode(msg.sender, "MyContract-v1")); // Include constructor args in salt for uniqueness bytes32 salt = keccak256(abi.encode(msg.sender, name, symbol, initialSupply)); ``` ## Cross-Chain Same-Address Deployment To deploy at the same address on multiple chains: 1. Use the same factory contract address on all chains (deploy factory with CREATE2 from an EOA at same nonce, or use a known factory like Arachnid's) 2. Use the same salt 3. Use the same creation code (including constructor arguments) ```solidity // Arachnid's deterministic deployment proxy (deployed on most chains): // 0x4e59b44847b379578588920cA78FbF26c0B4956C // Deploy to same address on any chain: bytes memory initCode = abi.encodePacked(type(MyContract).creationCode, abi.encode(arg1, arg2)); bytes32 salt = keccak256("my-protocol-v1"); // Submit identical tx to factory on each chain ``` ## CREATE3 Pattern (Address Independent of Init Code) CREATE3 makes the deployed address independent of constructor arguments. Useful when constructor args differ per chain but you want the same address: ```solidity library CREATE3 { bytes internal constant PROXY_BYTECODE = hex"67363d3d37363d34f03d5260086018f3"; bytes32 internal constant PROXY_BYTECODE_HASH = keccak256(PROXY_BYTECODE); function deploy(bytes32 salt, bytes memory creationCode, uint256 value) internal returns (address deployed) { // Step 1: deploy a minimal proxy via CREATE2 (deterministic) address proxy; assembly { proxy := create2(0, add(PROXY_BYTECODE, 0x20), mload(PROXY_BYTECODE), salt) } require(proxy != address(0), "CREATE3: proxy deploy failed"); // Step 2: proxy deploys the real contract via CREATE (nonce-based) // The real contract address = f(proxy address, nonce=1) (bool ok,) = proxy.call{value: value}(creationCode); require(ok, "CREATE3: deploy failed"); deployed = addressOf(salt); } function addressOf(bytes32 salt) internal view returns (address) { address proxy = address(uint160(uint256(keccak256(abi.encodePacked( bytes1(0xff), address(this), salt, PROXY_BYTECODE_HASH ))))); return address(uint160(uint256(keccak256(abi.encodePacked( bytes2(0xd694), proxy, bytes1(0x01) ))))); } } ``` ## Replay Protection Prevent the same contract from being deployed twice to the same address: ```solidity contract SafeCreate2Factory { mapping(address => bool) public isDeployed; function deploy(bytes32 salt, bytes memory creationCode) external payable returns (address deployed) { deployed = _computeAddress(salt, creationCode); require(!isDeployed[deployed], "Already deployed"); assembly { deployed := create2(callvalue(), add(creationCode, 0x20), mload(creationCode), salt) } require(deployed != address(0), "Deploy failed"); isDeployed[deployed] = true; } } ``` ## Vanity Addresses Mine salts for addresses with desirable prefixes: ```solidity // Off-chain salt mining (pseudocode) // for salt in 0..2^256: // addr = computeCreate2Address(factory, salt, initCodeHash) // if addr starts with 0x0000: // return salt // Use create2crunch or similar GPU miner for efficient vanity search ``` ```bash # create2crunch: GPU-accelerated vanity address mining create2crunch --factory 0xFactory... --caller 0xCaller... \ --init-code-hash 0xHash... --leading 4 --total 6 ``` ## Foundry Testing ```solidity function test_create2_deterministic() public { bytes32 salt = keccak256("test-salt"); bytes memory initCode = abi.encodePacked( type(MyContract).creationCode, abi.encode("arg1", 42) ); address predicted = factory.computeAddress(salt, initCode); address deployed = factory.deploy(salt, initCode); assertEq(deployed, predicted, "Address mismatch"); assertGt(deployed.code.length, 0, "No code at address"); } function test_create2_sameAddressDifferentChains() public { bytes32 salt = keccak256("cross-chain"); bytes memory initCode = type(MyContract).creationCode; // Same factory + salt + initCode = same address regardless of chain address addr = factory.computeAddress(salt, initCode); assertTrue(addr != address(0)); } ``` ## Key Considerations - CREATE2 address depends on init code, so different constructor args = different address - CREATE3 removes init code dependency (address depends only on factory + salt) - If a contract is `selfdestruct`ed, a new contract CAN be deployed at the same CREATE2 address - `selfdestruct` is deprecated post-Dencun (EIP-6780) — only works in same tx as creation - Always verify the deployed bytecode matches expectations after cross-chain deployment