A hook, start to finish

curl -L https://foundry.paradigm.xyz | bash && foundryup
cargo install --locked cargo-stylus
rustup target add wasm32-unknown-unknown

git clone --recurse-submodules https://github.com/youtpout/stylus-hook
cd stylus-hook

Storage and the entry point

An ordinary Stylus contract. The hook owns its state directly — this is the contract the pool manager calls.

#[storage]
#[entrypoint]
pub struct Counter {
    before_swap_count: StorageMap<FixedBytes<32>, StorageU256>,
    after_swap_count: StorageMap<FixedBytes<32>, StorageU256>,
    before_add_liquidity_count: StorageMap<FixedBytes<32>, StorageU256>,
    before_remove_liquidity_count: StorageMap<FixedBytes<32>, StorageU256>,
}

The pool manager is not a field. Solidity keeps it in an immutable, which costs nothing to read; the Stylus SDK has no equivalent, so a constructor argument could only go to storage and every callback would pay a cold SLOAD — 2,100 gas — just to check its caller. A Rust const lives in the WASM and is free, so build.rs bakes the address in at compile time:

include!(concat!(env!("OUT_DIR"), "/pool_manager.rs"));   // gives you POOL_MANAGER

Measured, that is worth 2,568 gas per swap on this hook, which is called twice. The cost is that the address is fixed at build time, and every cargo command needs it in the environment:

POOL_MANAGER=0x46b1852A2896902CcE7C5613AD5da97497a6F0C6 \
  cargo build -p stylus-native-counter

A static is not an alternative. It compiles, and a Stylus program is instantiated per call, so anything written to one is silently gone by the next call.

Declare the pool manager and the permissions

permissions() must match the callbacks you implement exactly, because this is what the mined address will encode and what v4 will read back out of it.

impl HookConfig for Counter {
    fn pool_manager(&self) -> Address {
        POOL_MANAGER
    }

    fn permissions(&self) -> Permissions {
        Permissions::none()
            .with_before_swap()
            .with_after_swap()
            .with_before_add_liquidity()
            .with_before_remove_liquidity()
    }
}

Those four flags are 0x0ac0, and that is what the low 14 bits of the deployed address will have to be.

Validate both addresses in the constructor

validate_hook_address reverts unless the deployed address carries exactly the declared flags — the same assertion Solidity's BaseHook makes. It is why a plain cargo stylus deploy cannot deploy a hook, and why step 5 mines a salt first.

The constructor also takes the pool manager, purely to compare it with the baked-in constant. Building against the wrong $POOL_MANAGER would otherwise give you a hook that compiles, deploys, mines a valid address, and then silently rejects every call the pool manager makes.

#[public]
#[implements(IHooks)]
impl Counter {
    #[constructor]
    pub fn constructor(&mut self, pool_manager: Address) -> Result<(), Vec<u8>> {
        if pool_manager != POOL_MANAGER {
            return Err(PoolManagerMismatch { baked: POOL_MANAGER, given: pool_manager }.abi_encode());
        }
        HookGuards::validate_hook_address(self)
    }

    pub fn before_swap_count(&self, pool_id: FixedBytes<32>) -> U256 {
        self.before_swap_count.get(pool_id)
    }
}

The check costs 239 gas per swap — not the constructor, which runs once, but the slightly larger program, which ArbWasm prices by compiled size. Cheap for turning a silent misconfiguration into a failed deployment.

Implement the callbacks

Write only the ones permissions() declares. The rest keep the base implementation and revert with HookNotImplemented. Each returns its own selector, which v4 checks on the way out.

#[guarded_hooks]
#[public]
impl IHooks for Counter {
    fn before_swap(
        &mut self,
        _sender: Address,
        key: PoolKey,
        _params: SwapParams,
        _hook_data: Bytes,
    ) -> Result<(FixedBytes<4>, BeforeSwapDelta, U24), Vec<u8>> {
        // the caller is the pool manager and `key` names this hook: both already checked
        Self::bump(&mut self.before_swap_count, key.to_id());
        Ok((selector::BEFORE_SWAP, ZERO_DELTA, U24::ZERO))
    }

    fn after_swap(
        &mut self,
        _sender: Address,
        key: PoolKey,
        _params: SwapParams,
        _delta: BalanceDelta,
        _hook_data: Bytes,
    ) -> Result<(FixedBytes<4>, i128), Vec<u8>> {
        Self::bump(&mut self.after_swap_count, key.to_id());
        Ok((selector::AFTER_SWAP, 0))
    }
}

BaseHook.sol is an abstract contract, so its onlyPoolManager guard cannot be forgotten. Rust has no abstract types, so #[guarded_hooks] does the same job as a procedural macro: it inserts the caller and pool-key checks into every method below it, and costs nothing.

A hook that returns a non-zero delta has to settle its own books before the lock closes. PoolManagerCalls wraps unlock, swap, take, settle, sync and extsload; native-twamm uses them for real.

Mine the address and deploy

The address derives from the init code, so rebuilding the contract changes the salt. Mine after the final build, never before.

export POOL_MANAGER=0xYourPoolManager        # baked in at build time, so set it first
cd stylus

cargo stylus get-initcode --contract stylus-native-counter | tail -1 > initcode.hex

cargo run -p stylus-hook-miner -- \
  --initcode-file initcode.hex \
  --permissions before-swap,after-swap,before-add-liquidity,before-remove-liquidity \
  --constructor-signature "$(cargo stylus constructor --contract stylus-native-counter | tail -1)" \
  --constructor-args $POOL_MANAGER

It prints the mined address, the salt, and the deploy command to run:

cargo stylus deploy --contract stylus-native-counter \
  --deployer-salt 0x… \
  --constructor-args $POOL_MANAGER \
  --endpoint https://sepolia-rollup.arbitrum.io/rpc \
  --private-key $PRIVATE_KEY

A contract too large for one code fragment cannot use get-initcode: the init code would contain fragment addresses that do not exist until the fragments are deployed. deploy_fragmented_hook in bench-lib.bash is the way round it.

cd uniswap && forge test     # the Solidity twins, through a real local v4 stack
cd stylus  && cargo test     # the Rust contracts, against stylus_sdk::testing::TestVM

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

cargo stylus check -e https://sepolia-rollup.arbitrum.io/rpc