Supported Protocols

Currently, Tycho supports the following protocols:

Protocol	Integration Type	Simulation Time	Chains	Partial Support Notes
uniswap_v2	Native (UniswapV2State)	1 μs (0.001 ms)	Ethereum, Base, Unichain
uniswap_v3	Native (UniswapV3State)	20 μs (0.02 ms)	Ethereum, Base, Unichain
uniswap_v4	Native (UniswapV4State)	3 μs (0.003 ms)	Ethereum, Base, Unichain	Only core uniswap V4 pools are supported on this native implementation.
uniswap_v4_hooks	Hybrid (UniswapV4State) [DCI indexed]	1 ms	Ethereum, Unichain	All composable hooks are supported. Angstrom: see more details below. recommended: set a high startup timeout on the stream builder: .startup_timeout(Duration::from_secs(120))
vm:balancer_v2	VM (EVMPoolState) [DCI indexed]	0.5 ms	Ethereum	A few pools are currently unsupported. Use balancer_v2_pool_filter
vm:curve	VM (EVMPoolState) [DCI indexed]	1 ms	Ethereum	NOTE: curve requires a node RPC to fetch some code at startup. Please set the RPC_URL env var.
sushiswap_v2	Native (UniswapV2State)	1 μs (0.001 ms)	Ethereum
pancakeswap_v2	Native (PancakeswapV2State)	1 μs (0.001 ms)	Ethereum
pancakeswap_v3	Native (UniswapV3State)	20 μs (0.02 ms)	Ethereum, Base
ekubo_v2	Native (EkuboState)	1.5 μs (0.0015 ms)	Ethereum
vm:maverick_v2	VM (EVMPoolState)	-	Ethereum
aerodrome_slipstreams	Native (AerodromeSlipstreamsState)	-	Base
rocketpool	Native (RocketpoolState)	-	Ethereum
fluid_v1	Native (FluidV1)	-	Ethereum	Note: paused pools are still indexed. To filter them out use fluid_v1_paused_pools_filter.
cowamm	Native (CowAMMState)	-	Ethereum	CoWAMM doesn't have a Tycho Execution component. This is because of CoWAMM's unique design where only cowswap solvers can unlock the liquidity pools after sharing a quote. You will have to integrate execution yourself (see cowamm docs and example).
ekubo_v3	Native (EkuboV3State)	9μs	Ethereum

Live tracker & Upcoming protocols

• Currently supported protocols and Tycho status: http://tycho.live/

• List of upcoming protocols

Register code snippet

fn register_exchanges(
    mut builder: ProtocolStreamBuilder,
    chain: &Chain,
    tvl_filter: ComponentFilter,
) -> ProtocolStreamBuilder {
    match chain {
        Chain::Ethereum => {
            builder = builder
                .exchange::<UniswapV2State>("uniswap_v2", tvl_filter.clone(), None)
                .exchange::<UniswapV2State>("sushiswap_v2", tvl_filter.clone(), None)
                .exchange::<PancakeswapV2State>("pancakeswap_v2", tvl_filter.clone(), None)
                .exchange::<UniswapV3State>("uniswap_v3", tvl_filter.clone(), None)
                .exchange::<UniswapV3State>("pancakeswap_v3", tvl_filter.clone(), None)
                .exchange::<EVMPoolState<PreCachedDB>>("vm:balancer_v2", tvl_filter.clone(), Some(balancer_v2_pool_filter))
                .exchange::<UniswapV4State>("uniswap_v4", tvl_filter.clone(), None)
                .exchange::<EkuboState>("ekubo_v2", tvl_filter.clone(), None)
                .exchange::<EVMPoolState<PreCachedDB>>("vm:curve", tvl_filter.clone(), None)
                .exchange::<UniswapV4State>("uniswap_v4_hooks", tvl_filter.clone(), None)
                .exchange::<EVMPoolState<PreCachedDB>>("vm:maverick_v2", tvl_filter.clone(), None)
                .exchange::<EkuboV3State>("ekubo_v3", tvl_filter.clone(), None)
        }
        Chain::Base => {
            builder = builder
                .exchange::<UniswapV2State>("uniswap_v2", tvl_filter.clone(), None)
                .exchange::<UniswapV3State>("uniswap_v3", tvl_filter.clone(), None)
                .exchange::<UniswapV4State>("uniswap_v4", tvl_filter.clone(), None)
                .exchange::<UniswapV3State>("pancakeswap_v3", tvl_filter.clone(), None)
                .exchange::<AerodromeSlipstreamsState>("aerodrome_slipstreams", tvl_filter.clone(), None)
        }
        Chain::Unichain => {
            builder = builder
                .exchange::<UniswapV2State>("uniswap_v2", tvl_filter.clone(), None)
                .exchange::<UniswapV3State>("uniswap_v3", tvl_filter.clone(), None)
                .exchange::<UniswapV4State>("uniswap_v4", tvl_filter.clone(), None)
        }
        _ => {}
    }
    builder
}

Integration Types

There are three types of protocol integrations:

• Native protocols have been implemented using an analytical approach and are ported to Rust - faster simulation.

• VM protocols execute the VM bytecode locally - this is easier to integrate the more complex protocols, however has slower simulation times than a native implementation.

  • Some VM protocols are DCI indexed. DCI is our Dynamic Contract Indexer and provides more flexibility on indexing restraints. Note - these protocols tend to serve a lot of data and experience occasional streaming delays.

• Hybrid uses a combination of the two - native for general protocol logic portable to Rust, and VM for the more complex or pool-specific logic.

Interested in adding a protocol? Refer to the Tycho Simulation for DEXs documentation for implementation guidelines.

Protocol-Specific Details

While most protocols work out of the box, some require additional configuration or have specific considerations you should be aware of.

Angstrom (Uniswap V4 Hook)

Angstrom requires querying their API for attestations per block to unlock their contract. If execution comes too late, the contract can no longer be unlocked for that block.

Required configuration:

• Set the ANGSTROM_API_KEY environment variable (request one from the Angstrom team directly)

• Set ANGSTROM_BLOCKS_IN_FUTURE environment variable (if you want to override the default value of 5 blocks). Important trade-off: The more blocks you fetch, the more calldata will be sent to the Tycho Router, making execution more gas expensive.