CREATE2 Address Calculator

Calculate deterministic smart contract addresses using CREATE2. Input deployer address, salt, and init code hash to predict deployment addresses.

Deployer Address

Salt (bytes32)

Init code input:

Init Code Hash (bytes32)

Examples

About CREATE2

CREATE2 (EIP-1014) enables deterministic contract deployment to predictable addresses
Formula: address = keccak256(0xff ++ deployer ++ salt ++ keccak256(initCode))[12:]
Use cases: counterfactual addresses, factory patterns (Uniswap), CREATE2-based wallets
The address depends only on the deployer, salt, and init code -- not on nonce

How to Use This CREATE2 Address Calculator

This tool computes the deterministic address where a smart contract will be deployed when using the CREATE2 opcode. Provide three inputs and the tool instantly calculates the resulting address.

Enter the deployer address — this is the address of the factory contract that will call CREATE2 (not your EOA address, unless deploying directly).
Enter the salt — a 32-byte hex value that you choose. Different salts produce different deployment addresses.
Enter the init code hash — the keccak256 hash of the contract creation bytecode (init code). You can get this from your compiler output or by hashing the bytecode with a keccak256 tool.
View the computed address — the tool shows the resulting contract address in checksummed format, ready to use in your deployment scripts.

All calculations run locally in your browser using standard keccak256 hashing.

Common Use Cases

Factory contract deployment — Predict addresses before deploying contracts through factory patterns like Uniswap V2/V3 pair creation.
Cross-chain deterministic addresses — Deploy contracts to the same address on multiple EVM chains by using the same deployer, salt, and init code.
Account abstraction (ERC-4337) — Calculate smart account addresses before deployment for counterfactual wallet creation.
Vanity address mining — Find salt values that produce contract addresses with desired properties like leading zeros.
Deployment verification — Verify that a deployed contract address matches your expected CREATE2 calculation before interacting with it.

Related Tools

Address Validator

Validate the computed CREATE2 address format and EIP-55 checksum.

Contract Size Calculator

Check that your contract bytecode fits within the 24KB EIP-170 limit before deploying.

Storage Slot Calculator

Calculate storage slot locations for deployed contract state variables and mappings.

Frequently Asked Questions

What is CREATE2 in Ethereum?

CREATE2 is an EVM opcode (0xf5) introduced in the Constantinople upgrade that allows deploying smart contracts to deterministic addresses. Unlike the regular CREATE opcode, the resulting address depends only on the deployer address, a salt value, and the init code hash, not on the deployer's nonce.

How is a CREATE2 address calculated?

A CREATE2 address is computed as: keccak256(0xff ++ deployerAddress ++ salt ++ keccak256(initCode))[12:]. The 0xff prefix prevents collisions with CREATE addresses. The deployer address is the contract calling CREATE2, the salt is a 32-byte value chosen by the deployer, and the init code is the contract creation bytecode.

What is the difference between CREATE and CREATE2?

CREATE calculates the contract address from the deployer's address and nonce, making the address depend on transaction ordering. CREATE2 uses a salt and init code hash instead of the nonce, so the address is deterministic and can be predicted before deployment. This enables counterfactual interactions with contracts before they exist.

What are vanity addresses with CREATE2?

By iterating over different salt values, developers can find a salt that produces a contract address with desired properties, such as leading zeros or a specific prefix. This is called salt mining or vanity address generation. It is commonly used for gas-efficient addresses (leading zeros save gas in calldata) or branding purposes.

What is counterfactual deployment?

Counterfactual deployment means interacting with a contract address before the contract is actually deployed. Because CREATE2 addresses are deterministic, users can send funds or grant permissions to the address in advance. The contract can be deployed later when needed. This pattern is used in state channels, account abstraction (ERC-4337), and factory contracts.

Related Tools & Guides

Keccak256 Hash Generator

Generate Keccak256 hashes from text input. The hash function used by Ethereum and Solidity.

Checksum Address Converter

Convert Ethereum addresses to EIP-55 checksummed format for safe usage in transactions.