wp_evm_aerodrome/

lib.rs

use alloy_primitives::{address, b256, Address, B256, U256};
use alloy_provider::{network::Ethereum, Provider};
use alloy_sol_types::SolCall;
use anyhow::{anyhow, Result};
use wp_evm_base::{chain::Chain, types::SlippageBps};
use wp_evm_ramses_provider as ramses;
use wp_evm_ramses_provider::data::RamsesProtocolConfig;
use wp_evm_v3_provider::plan::PeripherySelectors;
use wp_evm_velodrome_interfaces::periphery::router::ISlipstreamPeripheryRouter;

/// Selectors for `ISlipstreamPeripheryRouter` — Aerodrome's NFPM is a
/// Velodrome Slipstream fork on Base, sharing the same periphery interface
/// and selectors (verified by the Slipstream selector-lock tests in
/// `wp-evm-velodrome-interfaces`).
const SELECTORS: PeripherySelectors = PeripherySelectors {
    multicall: ISlipstreamPeripheryRouter::multicallCall::SELECTOR,
    unwrap_native: ISlipstreamPeripheryRouter::unwrapWETH9Call::SELECTOR,
    sweep_token: ISlipstreamPeripheryRouter::sweepTokenCall::SELECTOR,
    refund_native: ISlipstreamPeripheryRouter::refundETHCall::SELECTOR,
};

pub use wp_evm_ramses_provider::data::{
    CollectFeesParams, ExactInParams, ExactOutParams, PlanFragment, PoolState, PositionState,
    Quote, RamsesAddLiquidityParams, RemoveAndCollectParams, RemoveLiquidityParams,
};
pub use wp_evm_ramses_provider::position::{
    position_key, RamsesPositionView, VelodromePositionRow,
};
pub use wp_evm_ramses_provider::position_views::{PositionFees, PositionViewEntry};
pub use wp_evm_ramses_provider::quote::QuoteError;
pub use wp_evm_ramses_provider::Enumeration;

pub const CONFIG: RamsesProtocolConfig = RamsesProtocolConfig {
    factory: address!("5e7BB104d84c7CB9B682AaC2F3d509f5F406809A"),
    pool_deployer: Address::ZERO,
    router: address!("BE6D8f0d05cC4be24d5167a3eF062215bE6D18a5"),
    position_mgr: address!("827922686190790b37229fd06084350E74485b72"),
    init_code_hash: b256!("ffb9af9ea6d9e39da47392ecc7055277b9915b8bfc9f83f105821b7791a6ae30"),
    tick_spacings: &[1, 50, 100, 200, 2000],
    multicall: address!("cA11bde05977b3631167028862bE2a173976CA11"),
    quoter: Some(address!("254cF9E1E6e233aa1AC962CB9B05b2cfeAaE15b0")),
    voter: address!("16613524e02ad97eDfeF371bC883F2F5d6C480A5"),
};

pub fn config_for_chain(chain: Chain) -> Option<&'static RamsesProtocolConfig> {
    match chain {
        Chain::Base => Some(&CONFIG),
        Chain::Ethereum
        | Chain::Arbitrum
        | Chain::Optimism
        | Chain::Polygon
        | Chain::Bsc
        | Chain::Sonic
        | Chain::HyperEvm
        | Chain::Avalanche
        | Chain::Celo => None,
    }
}

pub fn factory(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.factory)
}
pub fn pool_deployer(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.pool_deployer)
}
pub fn position_manager(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.position_mgr)
}
pub fn router(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.router)
}
pub fn quoter(chain: Chain) -> Option<Address> {
    config_for_chain(chain).and_then(|c| c.quoter)
}
pub fn multicall(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.multicall)
}
pub fn init_code_hash(chain: Chain) -> Option<B256> {
    config_for_chain(chain).map(|c| c.init_code_hash)
}
pub fn voter(chain: Chain) -> Option<Address> {
    config_for_chain(chain).map(|c| c.voter)
}
pub fn supports(chain: Chain) -> bool {
    config_for_chain(chain).is_some()
}

pub async fn pool_state<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    pool: Address,
) -> Result<PoolState> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    // Aerodrome (Slipstream) pools have a 6-field slot0 (no feeProtocol) — the
    // V3 7-field `pool_state` reader overruns; use the Velodrome reader.
    ramses::hydrate::pool_state_velodrome(provider, cfg.multicall, pool).await
}

pub async fn position_state<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    token_id: U256,
) -> Result<PositionState> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    ramses::hydrate::position_state_slipstream(provider, cfg.multicall, cfg.position_mgr, token_id)
        .await
}

pub async fn position_views<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    token_ids: &[U256],
) -> Result<Vec<PositionViewEntry<VelodromePositionRow>>> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    ramses::position_views::velodrome_position_views(
        provider,
        cfg.multicall,
        cfg.position_mgr,
        token_ids,
    )
    .await
}

pub async fn position_views_with_nfpm<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    nfpm: Address,
    token_ids: &[U256],
) -> Result<Vec<PositionViewEntry<VelodromePositionRow>>> {
    let multicall =
        config_for_chain(chain).map(|cfg| cfg.multicall).unwrap_or(ramses::MULTICALL3_ADDRESS);
    ramses::position_views::velodrome_position_views(provider, multicall, nfpm, token_ids).await
}

pub async fn enumerate_owner_token_ids<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    nfpm: Address,
    owner: Address,
) -> Result<Enumeration> {
    let multicall =
        config_for_chain(chain).map(|cfg| cfg.multicall).unwrap_or(ramses::MULTICALL3_ADDRESS);
    ramses::enumerate_owner_token_ids(provider, multicall, nfpm, owner, chain).await
}

pub async fn populate_positions_fees<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    entries: &mut [PositionViewEntry<VelodromePositionRow>],
) -> Result<()> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    ramses::position_views::velodrome_populate_position_fees(
        provider,
        cfg.multicall,
        entries,
        |v| pool_address(chain, v.token0, v.token1, v.tick_spacing, None),
    )
    .await
}

pub fn quote_exact_in(s: &PoolState, p: &ExactInParams) -> Result<Quote, QuoteError> {
    ramses::quote::exact_in(s, p)
}
pub fn quote_exact_out(s: &PoolState, p: &ExactOutParams) -> Result<Quote, QuoteError> {
    ramses::quote::exact_out(s, p)
}

pub async fn populate_ticks<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    pool: Address,
    state: &mut PoolState,
) -> Result<()> {
    config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    ramses::populate_ticks::populate_ticks(provider, pool, state).await
}

pub async fn quote_online_exact_in<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    state: &PoolState,
    params: &ExactInParams,
) -> Result<Quote> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    let quoter =
        cfg.quoter.ok_or_else(|| anyhow!("Aerodrome quoter not registered on {chain:?}"))?;
    ramses::quote_online::quote_online_exact_in(provider, quoter, state, params).await
}

pub fn plan_swap_exact_in(
    s: &PoolState,
    q: &Quote,
    p: &ExactInParams,
    slippage: SlippageBps,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    Ok(ramses::plan::swap_exact_in(s, q, p, slippage, deadline, cfg.router))
}

pub fn plan_add_liquidity(
    p: &RamsesAddLiquidityParams,
    slippage: SlippageBps,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    Ok(ramses::plan::add_liquidity_slipstream(p, slippage, deadline, cfg.position_mgr))
}

/// Build an Aerodrome (Slipstream) NFPM `mint` plan fragment with precomputed
/// `amount0_min` / `amount1_min` (e.g. derived from a price-aware sqrt-ratio
/// quote). Mirrors `plan_add_liquidity` but takes the mins directly instead of
/// a flat slippage haircut.
pub fn plan_add_liquidity_with_min(
    p: &RamsesAddLiquidityParams,
    amount0_min: U256,
    amount1_min: U256,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    Ok(ramses::plan::add_liquidity_slipstream_with_min(
        p,
        amount0_min,
        amount1_min,
        deadline,
        cfg.position_mgr,
    ))
}

#[allow(clippy::too_many_arguments)]
pub fn plan_increase_liquidity(
    token_id: U256,
    token0: Address,
    token1: Address,
    amount0_desired: U256,
    amount1_desired: U256,
    slippage: SlippageBps,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    Ok(ramses::plan::increase_liquidity(
        token_id,
        token0,
        token1,
        amount0_desired,
        amount1_desired,
        slippage,
        deadline,
        cfg.position_mgr,
    ))
}

pub fn plan_remove_liquidity(
    p: &RemoveLiquidityParams,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    Ok(ramses::plan::remove_liquidity(p, deadline, cfg.position_mgr))
}

/// Build an atomic `multicall(decreaseLiquidity, collect, ..unwrap_tail)`
/// plan fragment for an Aerodrome (Base) NFPM position.
///
/// **Native ETH unwrap:** when `recipient == Address::ZERO`, composes
/// `multicall(decrease, collect, unwrapWETH9, sweepToken)` against the
/// NFPM. Aerodrome's NFPM is a Velodrome Slipstream fork on Base that
/// inherits Uniswap V3's `Multicall + PeripheryPayments` byte-for-byte
/// (verified against deployed Base NFPM `0x8279...5b72` in #232), so the
/// V3 composition is byte-for-byte portable.
///
/// For non-native recipients this is a thin pass-through —
/// `resolve_native_wrap_remove_and_collect` returns an empty `post_calls`
/// vec and the bare `multicall([decrease, collect])` is emitted unwrapped.
pub fn plan_remove_liquidity_and_collect(
    p: &RemoveAndCollectParams,
    deadline: u64,
    chain: Chain,
) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;

    let wrap = wp_evm_v3_provider::plan::resolve_native_wrap_remove_and_collect(
        p,
        cfg.position_mgr,
        chain,
    )?;

    let mut core_params = (*p).clone();
    core_params.recipient = wrap.effective_collect_recipient;

    let frag = ramses::plan::remove_liquidity_and_collect(&core_params, deadline, cfg.position_mgr);
    wp_evm_v3_provider::plan::compose_native_remove_collect_multicall(frag, &wrap, SELECTORS)
}

pub fn plan_collect_fees(p: &CollectFeesParams, chain: Chain) -> Result<PlanFragment> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;

    // Resolve `recipient == Address::ZERO` (native unwrap sentinel) by
    // composing `multicall(collect, unwrapWETH9, sweepToken)` against the
    // NFPM. Aerodrome's NFPM inherits Uniswap V3's `Multicall +
    // PeripheryPayments` byte-for-byte (verified 2026-05-29 against the
    // deployed Base NFPM at 0x8279...5b72), so the V3 Slice 3.5
    // composition (PR #210) is byte-for-byte portable.
    //
    // For non-native recipients this is a thin pass-through —
    // `resolve_native_wrap_collect` returns an empty `post_calls` vec
    // and the bare `collect()` calldata is emitted unwrapped.
    let wrap = wp_evm_v3_provider::plan::resolve_native_wrap_collect(p, cfg.position_mgr, chain)?;

    // Safety-critical for V3 forks: do not pass `recipient = 0` through
    // to the forked NFPM. Aerodrome is a V3 fork (with Velodrome ve(3,3)
    // additions) and we cannot rely on the upstream V3 `recipient == 0 ?
    // address(this) : recipient` substitution surviving every fork.
    // Mirroring V3 Slice 3.5's defensive guard.
    let core_params = CollectFeesParams {
        token_id: p.token_id,
        recipient: wrap.effective_recipient,
        token0: p.token0,
        token1: p.token1,
        caller: p.caller,
    };

    let frag = ramses::plan::collect_fees(&core_params, cfg.position_mgr);
    Ok(wp_evm_v3_provider::plan::compose_native_collect_multicall(frag, &wrap, SELECTORS))
}

pub fn pool_address(
    chain: Chain,
    token_a: Address,
    token_b: Address,
    tick_spacing: i32,
    init_code_hash_override: Option<B256>,
) -> Option<Address> {
    let cfg = config_for_chain(chain)?;
    let init_code_hash = init_code_hash_override.unwrap_or(cfg.init_code_hash);
    Some(ramses::pool_address::compute(cfg.factory, init_code_hash, token_a, token_b, tick_spacing))
}

pub async fn pending_emissions<P: Provider<Ethereum>>(
    provider: &P,
    chain: Chain,
    pool: Address,
    account: Address,
    token_id: U256,
) -> Result<Option<wp_evm_ramses_provider::velodrome_gauge::VelodromePendingEmissions>> {
    let cfg =
        config_for_chain(chain).ok_or_else(|| anyhow!("Aerodrome not deployed on {chain:?}"))?;
    wp_evm_ramses_provider::velodrome_gauge::pending_emissions(
        provider,
        cfg.multicall,
        cfg.voter,
        pool,
        account,
        token_id,
    )
    .await
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn config_for_chain_returns_some_for_base_only() {
        assert_eq!(config_for_chain(Chain::Base), Some(&CONFIG));
        for unsupported in [
            Chain::Ethereum,
            Chain::Arbitrum,
            Chain::Optimism,
            Chain::Polygon,
            Chain::Bsc,
            Chain::Sonic,
            Chain::Avalanche,
            Chain::Celo,
        ] {
            assert!(
                config_for_chain(unsupported).is_none(),
                "aerodrome should not surface {unsupported:?}",
            );
        }
    }

    /// `plan_add_liquidity_with_min` targets the NFPM (`cfg.position_mgr`) and
    /// threads the exact precomputed `amount0_min`/`amount1_min` into the core
    /// slipstream mint encoder (byte-identical to the bare core call, and
    /// distinct from a different-mins call).
    #[test]
    fn plan_add_liquidity_with_min_threads_precomputed_mins_at_position_manager() {
        let p = RamsesAddLiquidityParams {
            token0: address!("4200000000000000000000000000000000000006"),
            token1: address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"),
            tick_spacing: 100,
            tick_lower: -887_200,
            tick_upper: 887_200,
            amount0_desired: U256::from(1_000_000u64),
            amount1_desired: U256::from(500_000_000_000_000u64),
            recipient: address!("0000000000000000000000000000000000000099"),
        };
        let m0 = U256::from(123_456u64);
        let m1 = U256::from(789_012u64);
        let frag = plan_add_liquidity_with_min(&p, m0, m1, 9_999_999_999, Chain::Base)
            .expect("Base supported");
        assert_eq!(frag.calls.len(), 1);
        assert_eq!(frag.calls[0].target, CONFIG.position_mgr);
        assert_eq!(frag.approvals.len(), 2);

        let bare = ramses::plan::add_liquidity_slipstream_with_min(
            &p,
            m0,
            m1,
            9_999_999_999,
            CONFIG.position_mgr,
        );
        assert_eq!(frag.calls[0].calldata, bare.calls[0].calldata);
        let other = ramses::plan::add_liquidity_slipstream_with_min(
            &p,
            m0 + U256::from(1u64),
            m1,
            9_999_999_999,
            CONFIG.position_mgr,
        );
        assert_ne!(frag.calls[0].calldata, other.calls[0].calldata);
    }

    #[test]
    fn pool_address_matches_canonical_aerodrome_weth_usdc_cl100() {
        let pool = pool_address(
            Chain::Base,
            address!("4200000000000000000000000000000000000006"),
            address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"),
            100,
            None,
        )
        .expect("Base supported");
        assert_eq!(pool, address!("b2cc224c1c9feE385f8ad6a55b4d94E92359DC59"));
    }

    #[test]
    fn pool_address_token_order_independent() {
        let weth = address!("4200000000000000000000000000000000000006");
        let usdc = address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913");
        assert_eq!(
            pool_address(Chain::Base, weth, usdc, 100, None),
            pool_address(Chain::Base, usdc, weth, 100, None)
        );
    }

    #[test]
    fn plan_collect_fees_native_recipient_emits_multicall_with_unwrap_and_sweep() {
        // Aerodrome Base — native pair is USDC / WETH. ZERO recipient =
        // "user wants ETH back, not WETH" sentinel. Mirror of V3 Slice 3.5
        // (PR #210) — see `wp_evm_uniswap_v3::tests::plan_collect_fees_native_recipient_*`.
        let params = CollectFeesParams {
            token_id: U256::from(1u64),
            recipient: Address::ZERO,
            token0: address!("4200000000000000000000000000000000000006"), // WETH (Base)
            token1: address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"), // USDC (Base)
            caller: address!("dEaDbEEFdeAdBeEfDEadBeEFDeaDbEEfdeadbEEF"),
        };
        let frag = plan_collect_fees(&params, Chain::Base).expect("Base supported");

        assert_eq!(&frag.calls[0].calldata[..4], &[0xac, 0x96, 0x50, 0xd8]);
        assert_eq!(frag.calls[0].target, CONFIG.position_mgr);
        assert_eq!(frag.value, U256::ZERO);
        assert_eq!(frag.calls[0].value, U256::ZERO);
        assert!(
            frag.calls[0].calldata.windows(4).any(|w| w == [0x49, 0x40, 0x4b, 0x7c]),
            "native collect multicall must include unwrapWETH9(uint256,address) tail"
        );
        assert!(
            frag.calls[0].calldata.windows(4).any(|w| w == [0xdf, 0x2a, 0xb5, 0xbb]),
            "native collect multicall must include sweepToken(address,uint256,address) tail"
        );
    }

    #[test]
    fn plan_collect_fees_non_native_recipient_passthrough() {
        let params = CollectFeesParams {
            token_id: U256::from(1u64),
            recipient: address!("0000000000000000000000000000000000000099"),
            token0: address!("4200000000000000000000000000000000000006"),
            token1: address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"),
            caller: Address::ZERO,
        };
        let frag = plan_collect_fees(&params, Chain::Base).expect("Base supported");
        let bare = ramses::plan::collect_fees(&params, CONFIG.position_mgr);

        assert_ne!(
            &frag.calls[0].calldata[..4],
            &[0xac, 0x96, 0x50, 0xd8],
            "non-native case must NOT be wrapped in multicall"
        );
        assert_eq!(
            frag.calls[0].calldata, bare.calls[0].calldata,
            "non-native pass-through must stay byte-identical to bare collect()"
        );
    }

    #[test]
    fn plan_collect_fees_no_native_side_rejects() {
        // Both sides ERC20 (no WETH) with ZERO recipient — sentinel misuse;
        // nothing to unwrap. Must reject loudly.
        let params = CollectFeesParams {
            token_id: U256::from(1u64),
            recipient: Address::ZERO,
            token0: address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"), // USDC
            token1: address!("50c5725949A6F0c72E6C4a641F24049A917DB0Cb"), // DAI (Base)
            caller: address!("dEaDbEEFdeAdBeEfDEadBeEFDeaDbEEfdeadbEEF"),
        };
        let err = plan_collect_fees(&params, Chain::Base).unwrap_err();
        let msg = format!("{err:#}");
        assert!(msg.contains("neither") || msg.contains("native"), "got: {msg}");
    }

    // ---------------------------------------------------------------
    // plan_remove_liquidity_and_collect (native ETH unwrap) — mirrors
    // plan_collect_fees tests above; same WETH-paired Base pair.
    // ---------------------------------------------------------------

    fn fixture_remove_and_collect_params_weth_paired() -> RemoveAndCollectParams {
        RemoveAndCollectParams {
            token_id: U256::from(1u64),
            liquidity: 1_000_000u128,
            amount0_min: Some(U256::from(100u64)),
            amount1_min: Some(U256::from(200u64)),
            recipient: Address::ZERO,
            token0: address!("4200000000000000000000000000000000000006"), // WETH (Base)
            token1: address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"), // USDC (Base)
            caller: address!("dEaDbEEFdeAdBeEfDEadBeEFDeaDbEEfdeadbEEF"),
            burn: false,
        }
    }

    #[test]
    fn plan_remove_liquidity_and_collect_native_recipient_emits_4_call_multicall() {
        // WETH-paired Base position; native unwrap engaged via ZERO recipient.
        let params = fixture_remove_and_collect_params_weth_paired();
        let frag = plan_remove_liquidity_and_collect(&params, 9_999_999_999, Chain::Base)
            .expect("Base supported");

        assert_eq!(&frag.calls[0].calldata[..4], &[0xac, 0x96, 0x50, 0xd8]);
        assert_eq!(frag.calls[0].target, CONFIG.position_mgr);
        assert_eq!(frag.value, U256::ZERO);
        assert!(frag.approvals.is_empty());

        use alloy_sol_types::SolValue;
        let (inner,): (Vec<alloy_primitives::Bytes>,) =
            <(Vec<alloy_primitives::Bytes>,)>::abi_decode_params(&frag.calls[0].calldata[4..])
                .expect("decode outer multicall params");
        assert_eq!(inner.len(), 4, "expected 4 inner calls");
        assert_eq!(&inner[0][..4], &[0x0c, 0x49, 0xcc, 0xbe], "inner[0] = decreaseLiquidity");
        assert_eq!(&inner[1][..4], &[0xfc, 0x6f, 0x78, 0x65], "inner[1] = collect");
        assert_eq!(&inner[2][..4], &[0x49, 0x40, 0x4b, 0x7c], "inner[2] = unwrapWETH9");
        assert_eq!(&inner[3][..4], &[0xdf, 0x2a, 0xb5, 0xbb], "inner[3] = sweepToken");
    }

    #[test]
    fn plan_remove_liquidity_and_collect_non_native_recipient_passthrough() {
        let mut params = fixture_remove_and_collect_params_weth_paired();
        params.recipient = address!("0000000000000000000000000000000000000099");
        let frag = plan_remove_liquidity_and_collect(&params, 9_999_999_999, Chain::Base)
            .expect("Base supported");
        assert_eq!(&frag.calls[0].calldata[..4], &[0xac, 0x96, 0x50, 0xd8]);
        let bare =
            ramses::plan::remove_liquidity_and_collect(&params, 9_999_999_999, CONFIG.position_mgr);
        assert_eq!(
            frag.calls[0].calldata, bare.calls[0].calldata,
            "non-native pass-through must stay byte-identical to bare multicall([decrease, collect])"
        );
    }

    #[test]
    fn plan_remove_liquidity_and_collect_no_native_side_rejects() {
        let mut params = fixture_remove_and_collect_params_weth_paired();
        params.token0 = address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913"); // USDC (Base)
        params.token1 = address!("50c5725949A6F0c72E6C4a641F24049A917DB0Cb"); // DAI (Base)
        let err =
            plan_remove_liquidity_and_collect(&params, 9_999_999_999, Chain::Base).unwrap_err();
        let msg = format!("{err:#}");
        assert!(msg.contains("neither") || msg.contains("native"), "got: {msg}");
    }

    // -------------------------------------------------------------
    // Slice 3 Layer 2 chain-aware tests (per Slice 1+2 pattern)
    // -------------------------------------------------------------

    #[test]
    fn factory_returns_chain_specific_address_via_layer2() {
        assert_eq!(factory(Chain::Base), Some(CONFIG.factory));
        for unsupported in [
            Chain::Ethereum,
            Chain::Arbitrum,
            Chain::Optimism,
            Chain::Polygon,
            Chain::Bsc,
            Chain::Sonic,
            Chain::Avalanche,
            Chain::Celo,
        ] {
            assert_eq!(factory(unsupported), None);
        }
    }

    /// Structural canary for chain-aware multicall routing.
    ///
    /// Skip pattern: requires `BASE_RPC_URL` pointing at a Base archive
    /// node + `anvil` on PATH. Skips with eprintln otherwise.
    #[tokio::test]
    async fn pool_state_routes_to_chain_specific_multicall() {
        let Some(rpc) = std::env::var("BASE_RPC_URL").ok() else {
            eprintln!(
                "SKIP pool_state_routes_to_chain_specific_multicall: \
                 set BASE_RPC_URL to a Base archive RPC to enable"
            );
            return;
        };
        let anvil = alloy::node_bindings::Anvil::new().fork(rpc).spawn();
        let provider = alloy::providers::ProviderBuilder::new().connect_http(anvil.endpoint_url());

        // Canonical Aerodrome Base WETH/USDC CL100 pool — verified via
        // `pool_address_matches_canonical_aerodrome_weth_usdc_cl100`.
        let base_pool = address!("b2cc224c1c9feE385f8ad6a55b4d94E92359DC59");
        let state = pool_state(&provider, Chain::Base, base_pool)
            .await
            .expect("Base pool_state must succeed via Layer 2 chain-aware routing");
        assert!(state.liquidity > 0, "Real on-chain Aerodrome pool should have non-zero liquidity");
    }

    #[test]
    fn pool_address_with_override_uses_override_not_config_hash() {
        let weth = address!("4200000000000000000000000000000000000006");
        let usdc = address!("833589fCD6eDb6E08f4c7C32D4f71b54bda02913");
        let custom_hash = b256!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

        let with_override =
            pool_address(Chain::Base, weth, usdc, 100, Some(custom_hash)).expect("Base supported");
        let without_override =
            pool_address(Chain::Base, weth, usdc, 100, None).expect("Base supported");

        assert_ne!(with_override, without_override);
    }
}