Stylus Hook

Scaling Ethereum 2024

The original adapted a Uniswap limit-order hook to Stylus and won 1st place in the Arbitrum Stylus track.

• But the contract v4 called was Solidity — a proxy, forwarding every callback to the Stylus contract behind it.
• The logic was Rust. The hook was not. It was never Stylus end to end.

Both sides were pre-production

You cannot finish a bridge between two things that are both still moving. The honest call was to stop and wait.

Both shipped

• Uniswap v4.0.0 is released and live on Arbitrum
• Stylus is on mainnet, at version 3 on Arbitrum One
• Transient storage landed in ArbOS 32, so this runs against upstream v4-core with no fork
• cargo stylus deploy goes through StylusDeployer, which does CREATE2 on a non-zero salt

Every reason to stop in 2024 had been removed. So we finished it.

v4 asks a hook for exactly two things

The ABI was never the obstacle. The address was.

Three pieces, no Solidity

A test asserts all ten callback selectors computed from the Rust ABI equal those in the compiled IHooks.sol. A Rust hook is only a hook if the calls land on the right methods.

Five steps

// 1. storage and entry point — the hook owns its state
#[storage] #[entrypoint]
pub struct Counter { before_swap_count: StorageMap<FixedBytes<32>, StorageU256> }

// 2. declare the permissions the address will encode
fn permissions(&self) -> Permissions { Permissions::none().with_before_swap() }

// 3. constructor validates the mined address, or reverts
HookGuards::validate_hook_address(self)

// 4. implement only the declared callbacks
#[guarded_hooks] #[public]
impl IHooks for Counter { fn before_swap(..) { /* guards already inserted */ } }

// 5. mine the salt, then deploy to the address it prints
cargo run -p stylus-hook-miner -- --permissions before-swap

A real PoolManager, driving a Rust hook

./prove-native-hook.bash stands up an Arbitrum Nitro node, mines the address, deploys, and exercises every declared callback.

ok  landed on the mined address
ok  the code at that address is an activated Stylus program
ok  its constructor ran and validated the address
ok  beforeAddLiquidity reached the Rust hook
ok  beforeSwap reached the Rust hook
ok  afterSwap reached the Rust hook
ok  beforeRemoveLiquidity reached the Rust hook
ok  beforeDonate reverts with HookNotImplemented

Stylus is not faster. It is differently priced.

So a port pays off only above roughly 12,000 gas of Solidity arithmetic per call. That is the whole decision.

89 operations (mulDiv)

Most hooks should stay in Solidity

• A hook that only keeps books. Our counter costs 2.8× what the Solidity one does. Read a slot, add, write it back is the worst possible workload.
• Anything input-output bound. EulerSwap inverts a curve with a 255-bit square root and still spends 2 % of its gas on arithmetic, the rest querying vaults.
• Anything gated on a precompile. ecrecover, SHA-256, BN254, BLS12-381 are all live on Arbitrum and Stylus calls them at the same price.
• Anything expensive because of the algorithm it picked. Fix that first, in Solidity.

The gain tracks how badly the work fits a 256-bit word

Storage barely moves. Everything that is real arithmetic does.

A TWAMM under real order flow

Against akshatmittal/v4-twamm-hook by Uniswap Labs and Zaha Studio, audited by ABDK and Certora, live on Base and Unichain.

The fee is paid once. The saving is paid per stream.

Each extra stream costs 52,163 gas in Rust against 83,256 in Solidity. On a busy protocol the quiet benchmark is the worst case, and it already wins.

Post-quantum signatures

keccak256 has the 0x01 pad compiled in and SHAKE pads with 0x1f, so SHAKE cannot come from any built-in, in either language. A swap costs ~115,000 gas. Solidity would spend ninety-nine swaps to check one signature. Rust spends a third of one.