bag.watch home
Loading
← Back to notes

Mastering CREATE2: Predict, Mine, and Optimize Ethereum Contract Addresses with bag.watch

Learn how to harness the power of Ethereum's CREATE2 opcode to deterministically predict, mine, and optimize smart contract addresses. Explore vanity address generation, bit packing for gas optimization, and Uniswap V4-style configuration flags — all interactively inside your browser with bag.watch.

Deterministic Contract Deployment with CREATE2

Deterministic contract deployment is becoming the backbone of scalable, composable Ethereum dApps. CREATE2, introduced in EIP-1014 during the Constantinople hard fork, lets you pre-compute contract addresses before you ever publish them onchain — a superpower for factory patterns, counterfactual deployments, and reproducible pipelines.

Traditional CREATE deployments hinge on the deployer’s nonce, making addresses unpredictable and hard to coordinate. CREATE2 changes the equation by combining the deployer address, a salt, and the init code hash. The result is a predictable address you can share, monitor, and even simulate before deployment.

At bag.watch, our in-browser OLAP-EVM notebook lets you query live chain data, simulate deployments, and mine deterministic addresses — all without RPC servers or local binaries.

bag.watch is a browser-native EVM playground: SQL-first, zero-install, and built for deterministic deployment workflows.

TL;DR

  1. Learn how CREATE2 derives contract addresses you can predict before deployment.
  2. Use SQL functions like create2_predict and create2_mine to simulate or mine addresses directly in your browser.
  3. Apply this for factory deployments, vanity mining, or encoding configuration flags.
  4. Keep it all client-side — pure WebAssembly OLAP, no servers, no setup.

What is CREATE2 and Why It Matters

CREATE2 computes contract addresses using this formula:

address = keccak256(0xff ++ deployer_address ++ salt ++ init_code_hash)[12:]

Where:

  • deployer_address — the 20-byte EOA or contract deploying the new contract
  • salt — a 32-byte value you control
  • init_code_hash — keccak256 of the contract creation bytecode

Because it ignores the nonce, you can:

  • Interact with a contract before it exists (counterfactual deployment)
  • Give partners deterministic addresses for integrations or upgrades
  • Encode feature flags directly into address bits (Uniswap V4 style)
  • Mine vanity addresses or optimize for leading zeros to pack bits tightly

Predictability simplifies ops — you can pre-fund, simulate, and verify contract addresses before hitting mainnet.

The only challenge: brute-forcing salts can be CPU-heavy. bag.watch pushes this computation into your browser using a WebAssembly OLAP engine capable of hashing millions of salts in seconds.

Predicting Contract Addresses with create2_predict

The create2_predict function lets you deterministically derive contract addresses with a single SQL call. It’s available in two overloads — one for integer salts, one for full BYTES32 salts.

Hash the Init Code

Use keccak256 to hash your creation bytecode before predicting addresses.

1
-- Hash the init code for a minimal contract that stores 1 in slot 0
2
SELECT keccak256('0x6001600055') AS init_hash;
Notebook ready in readonly mode.

Predict an Address from Deployer + Salt

1
-- Predict a CREATE2 address using a numeric salt
2
SELECT create2_predict(
3
-- deployer: Vitalik's public EOA for demo purposes
4
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'::address,
5
-- salt: compact integer salt you control
6
42,
7
-- init_hash: keccak256 hash of the creation bytecode
8
keccak256('0x6001600055')
9
) AS contract_address;
Notebook ready in readonly mode.

Ability to predict what will be the address is great, but what if we want that address to be specific? create2_mine to the rescue!

Mining Vanity and Optimized Addresses with create2_mine

create2_mine is a DuckDB table function that performs a WebAssembly-accelerated, client-side brute force scan across salt ranges. You can scope the search with byte masks to lock in vanity patterns or protocol bitfields.

Branded Addresses Ending with dead

1
-- Mine vanity CREATE2 addresses ending with "dead"
2
SELECT salt, address AS vanity_address
3
FROM create2_mine(
4
-- deployer: any account or factory owner
5
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'::address,
6
-- init_hash: hashed init code, same as earlier
7
keccak256('0x6001600055'),
8
-- salt_start: begin scanning at salt 0
9
0,
10
-- salt_count: evaluate the next 500k salts
11
500000,
12
-- mask: restrict comparison to the last two bytes
13
'0x000000000000000000000000000000000000ffff'::address,
14
-- target: enforce a branded "dead" suffix
15
'0x000000000000000000000000000000000000dead'::address,
16
-- max_results: stop after 10 matches
17
10
18
);
Notebook ready in readonly mode.

Great for themed deployments, NFT branding, or vanity tokens — try suffixes like cafe, beef, 1337, or your DAO tag.

Leading Zeros for Bit Packing and Gas Optimization

1
-- Find addresses with leading zeros (useful for packing bits)
2
SELECT salt, address AS packed_address
3
FROM create2_mine(
4
-- deployer: unchanged across the scan
5
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'::address,
6
-- init_hash: deterministic bytecode hash
7
keccak256('0x6001600055'),
8
-- salt_start: first salt to test
9
0,
10
-- salt_count: sweep the next million salts
11
1000000,
12
-- mask: examine just the first two address bytes (leading 16 bits)
13
'0xffff000000000000000000000000000000000000'::address,
14
-- target: require those high-order bytes to be zero
15
'0x0000000000000000000000000000000000000000'::address,
16
-- max_results: grab the first five optimal hits
17
5
18
);
Notebook ready in readonly mode.

Addresses with 0x0000 prefixes reduce entropy in the high-order bits, making them ideal for bit-packing metadata or gas-efficient storage in rollups or onchain registries. Each additional zero byte you can guarantee constrains downstream indexing, which keeps binary storage and prefix lookups more compact.

Configuration Flags like Uniswap V4 Hooks

1
-- Encode configuration flags in low bits of the address
2
SELECT salt, address AS hook_address
3
FROM create2_mine(
4
-- deployer: the hook registry or owner
5
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'::address,
6
-- init_hash: keccak of a minimal hook init code stub
7
keccak256('0x600a600c600039600a6000f3fe60003660005360016000f3'),
8
-- salt_start: start from salt 0
9
0,
10
-- salt_count: 100k candidate salts
11
100000,
12
-- mask: inspect only the last byte
13
'0x00000000000000000000000000000000000000ff'::address,
14
-- target: require the flags byte to equal 0x01
15
'0x0000000000000000000000000000000000000001'::address,
16
-- max_results: return at most 10 matching hooks
17
10
18
);
Notebook ready in readonly mode.

This pattern mirrors Uniswap V4’s approach: the low-order bits of the contract address encode behavioral flags like “before swap” or “after hook.” Swap in your actual bytecode hash and toggle masks/targets to assign configuration bits while keeping deterministic deployment semantics.

Range Scan for Custom Filtering

1
-- Range-scan salts for custom post-processing
2
SELECT salt, address AS candidate
3
FROM create2_mine(
4
-- deployer: same baseline account
5
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'::address,
6
-- init_hash: minimal storage contract
7
keccak256('0x6001600055'),
8
-- salt_start: starting salt
9
0,
10
-- salt_count: evaluate 500 salts with no mask/target
11
500
12
);
Notebook ready in readonly mode.

You can post-process the resulting addresses directly in SQL to apply your own filters — perfect for advanced mining strategies or protocol analytics.

Best Practices for CREATE2 Mining

  • Start small (salt_count = 1000) before ramping to large scans.
  • Use mask + target filters to focus your search space.
  • Always verify predicted addresses before deployment.
  • Use unique salts in production (avoid replays).
  • Combine deterministic addresses with version-controlled init code for reproducible deployments.

Why Use bag.watch for CREATE2 Workflows

  • 100% browser-based OLAP over the EVM — no RPCs, no local setup.
  • Real-time create2_predict, create2_mine, and keccak256 functions.
  • Deterministic analytics, vanity mining, and address simulation in SQL.
  • Ideal for DEX factories, rollups, NFT launches, and low-gas deploy pipelines.

Try the live notebook at bag.watch and experiment with deterministic contract deployment, bit-packing, and vanity address mining — all inside your browser.