Vanity Addresses

Every LP24 token address begins 0x24. The factory enforces it at deployment, which makes protocol membership visible in the address itself.

Why enforce it

The prefix is a cheap, permanent marker. A wallet, explorer or bot can tell at a glance whether an address plausibly came from LP24, without a registry lookup. It is a necessary condition, not a sufficient one — the authoritative check is Factory.is_curve() on the paired curve — but it filters instantly.

Salt layout

deploy_pair takes a 32-byte salt with three fields:

Bytes	Field	Purpose
`[0:8]`	`anchor_block`	uint64 big-endian block number the salt commits to
`[8:16]`	`blockhash_prefix`	First 8 bytes of that block's hash
`[16:32]`	`miner_nonce`	Mined offline until the resulting address starts `0x24`

What the factory checks

anchor_block  = salt >> 192
assert anchor_block > 0
assert block.number > anchor_block                        // mined
assert block.number <= anchor_block + INCLUSION_WINDOW     // still fresh

anchor_hash = blockhash(anchor_block)
assert anchor_hash != 0                                    // within 256 blocks
assert (anchor_hash >> 192) == ((salt >> 128) & 0xFFFFFFFFFFFFFFFF)

effective_salt = keccak256(salt ‖ msg.sender)
token = create_minimal_proxy_to(token_master, effective_salt)
assert (token >> 152) == 0x24                              // vanity

The salt is bound to the caller

The salt handed to CREATE2 is keccak256(salt ‖ msg.sender), not the salt you supplied. A mined salt sitting in the mempool is therefore worthless to anyone else — copying it produces a different address that fails the vanity check. Anchor and blockhash validation still run against your original salt; only the CREATE2 input is domain-separated.

This also means you must mine against the effective salt, using your own deploying address as an input.

Inclusion window

The blockhash commitment ties a salt to a specific recent block, so salts cannot be mined far in advance. The window is the number of blocks after the anchor during which the deployment may land, and it is set per chain to roughly comparable wall-clock time:

Chain	Base	BSC	Polygon	Robinhood	Gnosis
`INCLUSION_WINDOW`	10 blocks	44 blocks	12 blocks	200 blocks	5 blocks

Miss the window and the transaction reverts with Too late. Re-mine against a fresh anchor and resubmit. On chains with short windows, mine against an anchor only once you are ready to broadcast.

Blockhash availability

blockhash() returns zero for blocks more than 256 back. Every chain's inclusion window is far inside that, but a transaction stuck in the mempool long enough will fail with Blockhash unavailable rather than Too late.

Mining a salt

Off-chain, iterate miner_nonce and compute the CREATE2 address for each candidate until the first byte is 0x24:

address = keccak256(0xff ‖ factory ‖ keccak256(salt ‖ deployer) ‖ keccak256(proxy_initcode))[12:]

The proxy initcode is the EIP-1167 stub pointing at the token master, so it is fixed per chain. One byte of prefix is a 1-in-256 hit rate — a few thousand iterations, effectively instant.

The bonding curve is deployed without a salt and gets no vanity treatment; only the token address carries the prefix.