feat: integrate Camelot V3 on Arbitrum One

[dvansari65]

Adds Camelot V3 on Arbitrum One as a VM integration: vm:camelot_v3, component type camelot_v3_pool.

Camelot V3 is an Algebra V1.9 deployment (factory 0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B, created at block 101163738). Its fee is adaptive and differs per direction, computed by a per-pool DataStorageOperator from stored price history; swaps write oracle timepoints; the tick spacing is mutable. The integration runs the pool as deployed rather than porting that logic.

Indexing (protocols/substreams/arbitrum-camelot-v3)

• Pools are discovered from the factory's Pool event on non-reverted factory call frames.
• The DataStorageOperator appears in no event. createPool deploys it with CREATE right before the pool deployer deploys the pool, so it is recovered from the call trace as the single contract the factory call creates; any other shape is an error.
• Each component links the pool, its operator and the factory (read for vaultAddress when a community fee is paid). Code and storage of all three are emitted from the factory's creation block.
• Balances come from both sides of ERC20 Transfer events on pool tokens.
• Incentive events are exposed as the active_incentive state attribute. A pool with a non-zero incentive calls an unindexed virtual pool and is filtered out in simulation. The factory's farmingAddress is currently zero.
• ABIs are the verified factory and pool ABIs from Blockscout.

Simulation (protocols/adapter-integration/evm/src/camelot-v3)

• CamelotV3SwapAdapter pays swaps in algebraSwapCallback, authenticated against factory.poolByPair, and quotes by reverting inside that callback with a tagged payload.
• Marginal prices come from the pool's sqrt price and the fee it will charge next; for a zero amount, a 1 wei quote reads the fee the first swap of the block would set.
• Limits walk the tick table read-only through tickTable and ticks, mirroring the native Uniswap V3 implementation, capped at 400 steps. Quoting through the pool costs 8M gas and more on liquid pools because every crossed tick writes storage, above the 8M the engine grants a call. The walk measured 3.3M to 6.0M gas on the WETH/USDC and WETH/ARB pools.
• CamelotV3TickMath ports getSqrtRatioAtTick, the token delta functions and nextTickInTheSameRow from the verified pool source.
• Runtime registered in vm/constants.rs; filter in filters.rs and EXCHANGES_REQUIRING_FILTER.

Execution

• Camelot pools expose the same swap(address,bool,int256,uint160,bytes) as Uniswap V3 and settle through algebraSwapCallback, which the router's selector-agnostic fallback() delivers to the executor. vm:camelot_v3 therefore reuses the deployed UniswapV3Executor on Arbitrum, as ramses_v3 does.
• CamelotV3SwapEncoder emits the executor's 64-byte payload with the fee slot zeroed; the executor never reads it.
• Config, gas estimator (PROTOCOLS_CALLBACK), test harness mapping and the executor address table are updated.

Verification

• Substreams: builds to wasm; 9 unit tests (parameter parsing and pool discovery on a synthetic createPool trace); clippy and fmt clean. Streamed block 101213149 through the package on StreamingFast: the emitted component, balances and storage match the chain, including the tick and bitmap slots of the first mint.
• Adapter: 18 Foundry fork tests at Arbitrum block 504411371, including the shared runPoolBehaviourTest on two pools.
• Execution: encoder unit test, calldata integration test, and a TychoRouterV3 fork test (WETH to USDC via Camelot at block 504411773) checking the exact output and the community fee split.
• Workspace clippy with -D warnings, fmt, cargo doc, no-default-features check.

Not run here: the protocols/testing range tests in integration_test.tycho.yaml (need Postgres, an Arbitrum archive RPC and a Substreams token). The harness previously had no Arbitrum Substreams endpoint; this adds it.

[die-herdplatte]

_{🤖 Claude Code ──────────────────────────}

I'd like to see Camelot V3 integrated natively rather than through the VM. As far as I can see, nothing stands in the way:

• Swap math. The swap step (PriceMovementMath.movePriceTowardsTarget) is Uniswap V3's computeSwapStep: same fee on input, same rounding, same rule for the remainder. The Uniswap V3 swap loop carries over, with feeZto/feeOtz in place of one fee.
• Indexing. Ticks, liquidity, price and the current fee all come from pool events (Mint, Burn, Swap, Fee), like ethereum-uniswap-v3. The community fee and tick spacing don't affect quotes, and incentives don't either (see incentive-guard-in-adapter).
• The adaptive fee is the real work, and it has precedent. At a new timestamp t the pool recomputes its fee from the operator's timepoints: the last one and the one before it, the oldest one, and the pair that DataStorage.binarySearch finds around t − 1 day, interpolated. aerodrome_slipstreams already does this end to end. It emits its oracle ring as observations/{idx} straight from storage changes (protocols/substreams/base-aerodrome-slipstreams/src/storage/pool_storage.rs:164), decodes the ring (crates/tycho-simulation/src/evm/protocol/aerodrome_slipstreams/decoder.rs:178-188), sets the execution timestamp in apply_block (crates/tycho-simulation/src/evm/protocol/aerodrome_slipstreams/state.rs:641), and runs the TWAP search on demand while quoting. Camelot additionally needs the fee configs (the operator's FeeConfiguration event) and volumePerLiquidityInBlock. A swap at a new timestamp must also write its timepoint and fee into the new state.
• Pruning the ring. Camelot's ring is a fixed 65,536 entries. It has already wrapped on WETH/USDC and WETH/ARB, yet only 3,835 and 2,571 of those timepoints fall within the last day. Emitting every write would ship the whole ring in each snapshot, about 4 MB raw per busy pool. Timestamps only increase along the ring, and execution time only moves forward. So after a write at t, everything older than the newest timepoint at or before t − 1 day is unreachable and can be deleted with ChangeType::Deletion, as Slipstreams already does for ticks (protocols/substreams/base-aerodrome-slipstreams/src/storage/pool_storage.rs:102-108). Choosing which indices to delete needs a small per-pool index → timestamp store.

walk-cap-exceeds-swap-gas, boundary-pool-stops-stream, incentive-guard-in-adapter and fee-keyed-on-timestamp are about the VM adapter. They show why it doesn't hold up against the engine; there is no need to fix them. Much of this PR carries over: pool discovery, the transfer-based balances, the execution wiring, and the careful verification against the Camelot source (the slot-4 packing, the tick-table port, and recovering the operator from the createPool trace all check out).

The PR description lags the code: active_incentive comes from the storage slot, not from Incentive events; only the factory ABI is vendored; and there are 12 substreams unit tests, not 9.

_{────────────────────────────────────────────────────}

[github-actions]

All contributors have signed the CLA ✍️ ✅
_{Posted by the CLA Assistant Lite bot.}

[dvansari65]

I have read the PropellerHeads CLA and I hereby sign the CLA