Tycho

https://docs.propellerheads.xyz/tycho
Admin
Tycho is a blockchain trading infrastructure platform that provides real-time market data indexing,...
Tokens:61,282
Snippets:700
Trust Score:8.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Quickstart Output Example

Source: https://docs.propellerheads.xyz/tycho

Example output from the quickstart, showing market data and swap details. It indicates if simulation/execution was skipped due to a missing private key.

```text
Looking for pool with best price for 10 USDC -> WETH

==================== Received block 14222319 ====================

The best swap (out of 6 possible pools) is:
Protocol: "uniswap_v3"
Pool address: "0x65081cb48d74a32e9ccfed75164b8c09972dbcf1"
Swap: 10.000000 USDC -> 0.006293 WETH 
Price: 0.000629 WETH per USDC, 1589.052587 USDC per WETH

Signer private key was not provided. Skipping simulation/execution. Set PRIVATE_KEY env variable to perform simulation/execution.
```

--------------------------------

### Run Quickstart on Mainnet

Source: https://docs.propellerheads.xyz/tycho

Execute the quickstart example on the Ethereum Mainnet. Ensure your private key is not saved to bash history by unsetting HISTFILE.

```bash
unset HISTFILE # to not save your private key to your bash history
export RPC_URL=https://ethereum.publicnode.com
export PRIVATE_KEY=<your-private-key>
cargo run --release --example quickstart --
```

--------------------------------

### Run Quickstart on Unichain

Source: https://docs.propellerheads.xyz/tycho

Execute the quickstart example on the Unichain. Ensure your private key is not saved to bash history by unsetting HISTFILE.

```bash
unset HISTFILE # to not save your private key to your bash history
export RPC_URL=https://unichain-rpc.publicnode.com
export PRIVATE_KEY=<your-private-key>
cargo run --release --example quickstart -- --chain unichain
```

--------------------------------

### Run RFQ Quickstart Example

Source: https://docs.propellerheads.xyz/tycho/for-solvers/request-for-quote-protocols

Execute the provided RFQ quickstart example using Cargo.

```rust
cargo run --release --example rfq_quickstart
```

--------------------------------

### Run Quickstart on Base Chain

Source: https://docs.propellerheads.xyz/tycho

Execute the quickstart example on the Base chain. Ensure your private key is not saved to bash history by unsetting HISTFILE.

```bash
unset HISTFILE # to not save your private key to your bash history
export RPC_URL=https://base-rpc.publicnode.com
export PRIVATE_KEY=<your-private-key>
cargo run --release --example quickstart -- --chain base
```

--------------------------------

### Execute Swap via Cargo

Source: https://docs.propellerheads.xyz/tycho/for-solvers/request-for-quote-protocols

Run the quickstart example to perform swaps using a provided private key.

```bash
cargo run --release --example quickstart -- --swapper-pk $PK
```

--------------------------------

### Enable Detailed Logging

Source: https://docs.propellerheads.xyz/tycho

Run the quickstart example with detailed logging enabled by setting the RUST_LOG environment variable to 'info'.

```bash
RUST_LOG=info cargo run --release --example quickstart
```

--------------------------------

### Complete Docker Test Setup for BalancerV2

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/3.-testing

This example demonstrates the complete setup for running tests for ethereum-balancer-v2 using Docker. It includes setting environment variables, building the Docker image, and running the test containers.

```bash
# Setup Environment Variables
export RPC_URL="https://ethereum-mainnet.core.chainstack.com/123123123123"
export SUBSTREAMS_API_TOKEN=eyJhbGci...
export PROTOCOLS="ethereum-balancer-v2"

# Build image
docker buildx build -f protocol-testing/run.Dockerfile -t protocol-testing-test-runner:latest --load .

# Run test
cd protocol-testing/
docker compose up -d && docker compose logs test-runner --follow
```

--------------------------------

### Install Substreams from Source

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/1.-setup

Compile and install Substreams from its source code using Go. This requires Git and Go to be installed.

```bash
git clone https://github.com/streamingfast/substreams
cd substreams
go install -v ./cmd/substreams
```

--------------------------------

### Install Buf with Homebrew

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/1.-setup

Install the Buf CLI using Homebrew. Refer to the official Buf website for alternative installation methods.

```bash
brew install bufbuild/buf/buf
```

--------------------------------

### Install Rust

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/1.-setup

Install Rust using the official installation script. This is a prerequisite for building Rust-based projects.

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

--------------------------------

### Run RFQ Quickstart with Custom Flags

Source: https://docs.propellerheads.xyz/tycho/for-solvers/request-for-quote-protocols

Execute the RFQ quickstart with specific token, amount, TVL, and chain parameters.

```bash
cargo run --release --example rfq_quickstart -- --sell-token "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" --buy-token "0x4200000000000000000000000000000000000006" --sell-amount 10 --tvl-threshold 1000 --chain "base"
```

--------------------------------

### Install Substreams with Homebrew

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/1.-setup

Install the Substreams CLI using Homebrew. Ensure you have Homebrew installed before running this command.

```bash
brew install streamingfast/tap/substreams
```

--------------------------------

### Run price printer example via CLI

Source: https://docs.propellerheads.xyz/tycho/for-solvers/simulation

Executes the price printer example with a specified TVL threshold using an RPC URL.

```bash
export RPC_URL=<your-eth-rpc-url>
cargo run --release --example price_printer -- --tvl-threshold 1000
```

--------------------------------

### Install Foundry

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/contributing-guidelines

Commands to install the Foundry toolchain for Solidity development.

```bash
curl -L https://foundry.paradigm.xyz | bash
foundryup
```

--------------------------------

### Install Tycho CLI

Source: https://docs.propellerheads.xyz/tycho/for-solvers/execution/encoding

Builds the Tycho project in release mode and installs the `tycho-encode` binary to the system's PATH.

```bash
# Build the project
cargo build --release

# Install the binary to your system
cargo install --path .
```

--------------------------------

### Clone and Install SDK Dependencies

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/simulation

Commands to clone the Tycho Protocol SDK and install necessary EVM dependencies.

```bash
git clone https://github.com/propeller-heads/tycho-protocol-lib
```

```bash
cd ./tycho-protocol-lib/evm/
forge install
```

--------------------------------

### Install Tycho Indexer Python Client

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/python-client

Install the Python client package from its GitHub repository. Ensure you have Git, Rust, and Python 3.9+ installed.

```bash
pip install git+https://github.com/propeller-heads/tycho-indexer.git#subdirectory=tycho-client-py
```

--------------------------------

### Customizing Swap Parameters

Source: https://docs.propellerheads.xyz/tycho

Run the quickstart with custom parameters for tokens, amounts, TVL threshold, and chain. Set TYCHO_URL and TYCHO_API_KEY for the specified chain.

```bash
export TYCHO_URL=<tycho-api-url-for-chain>
export TYCHO_API_KEY=<tycho-api-key-for-chain>
cargo run --release --example quickstart -- --sell-token "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" --buy-token "0x4200000000000000000000000000000000000006" --tvl-threshold 100 --sell-amount 10 --chain "base"
```

--------------------------------

### Run Range Tests for Ethereum Balancer V2

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/3.-testing

An example demonstrating how to set up environment variables and run range tests for a specific package like 'ethereum-balancer-v2'.

```bash
# Setup Environment Variables
export RPC_URL="https://ethereum-mainnet.core.chainstack.com/123123123123"
export SUBSTREAMS_API_TOKEN=eyJhbGci...
export RUST_LOG=info,protocol_testing=info,tycho_client=error

```

--------------------------------

### Verify Tycho Installation

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/binary-cli

Check the installed version of the Tycho client.

```bash
tycho-client --version
tycho-client 0.54.0 # should match the latest version published on GitHub
```

--------------------------------

### Verify Tycho Indexer Installation

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/3.-testing

Check the installed version of the Tycho Indexer to confirm the installation was successful. The version should match the latest release on GitHub.

```bash
> tycho-indexer --version
tycho-indexer 0.88.0 # should match the latest version published on GitHub
```

--------------------------------

### Display token balances

Source: https://docs.propellerheads.xyz/tycho

Example output showing current token balances for the wallet.

```text
Your balance: 100.000000 USDC
Your WETH balance: 1.500000 WETH
```

--------------------------------

### Execution output

Source: https://docs.propellerheads.xyz/tycho

Example output showing the results of a successful on-chain swap execution.

```text
Executing by performing an approval (for permit2) and a swap transaction...

Approval transaction sent with hash: 0xf2a9217016397b09f5274e225754029ebda31743b4da7dd1441e13971e1f43b0 and status: true

Swap transaction sent with hash: 0x0b26c9965b4ee39b5646ab93070f018c027ac3d0c9d56548a6db4412be7abbc8 and status: true

✅ Swap executed successfully! Exiting the session...

Summary: Swapped 10.000000 USDC → 0.006293 WETH at a price of 0.000629 WETH per USDC
```

--------------------------------

### Initialization Flow

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/complete-case-study-euler-hooks-external-liquidity-example

Initial setup steps for loading and filtering Uniswap V4 hook components.

```text
1. Load all uniswap_v4_hooks components from database
2. Filter for components with swap hook permissions
3. Check if entrypoints already exist
   - Has entrypoints → State = TracingComplete
   - No entrypoints → State = Unprocessed
4. Cache all components and states
```

--------------------------------

### Solidity Test Contract Example

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/execution

Example of a Solidity test contract inheriting from TychoRouterTestSetup. Override getForkBlock to set a specific block for testing and implement testSingleYourProtocolIntegration for your custom logic.

```Solidity
contract TychoRouterForYouProtocolTest is TychoRouterTestSetup {
    function getForkBlock() public pure override returns (uint256) {
        return 22644371; // Use a block that fits your test scenario
    }

    function testSingleYourProtocolIntegration() public {
        ...
    }
}
```

--------------------------------

### Sign fee parameters in Rust

Source: https://docs.propellerheads.xyz/tycho/for-solvers/execution/encoding

Example implementation for signing client fee parameters using the alloy library.

```rust
use alloy::primitives::{keccak256, Address, B256, U256};
use alloy::signers::{local::PrivateKeySigner, SignerSync};
use alloy::sol_types::SolValue;

fn sign_client_fee(
    chain_id: u64,
    router_address: Address,
    client_fee_bps: u16,
    client_fee_receiver: Address,
    max_client_contribution: U256,
    deadline: U256,
    signer: &PrivateKeySigner,
) -> Vec<u8> {
    // Must match CLIENT_FEE_TYPEHASH in TychoRouter.sol
    let type_hash: B256 = keccak256(
        b"ClientFee(uint16 clientFeeBps,address clientFeeReceiver,\
          uint256 maxClientContribution,uint256 deadline)",
    );

    // EIP-712 domain separator
```

--------------------------------

### Create a Solution with Multiple Swaps

Source: https://docs.propellerheads.xyz/tycho/for-solvers/execution/encoding

This example demonstrates how to define a series of swaps for a solution, including splitting amounts across different pools and handling the remainder. Use this when a single input token needs to be swapped through multiple intermediate tokens to reach the final output token.

```rust
swap_a = Swap::new(
    pool_a,
    weth_address,
    usdc_address,
    0.3, // 30% of WETH amount
);
swap_b = Swap::new(
    pool_b,
    weth_address,
    usdc_address,
    0.3, // 30% of WETH amount
);
swap_c = Swap::new(
    pool_c,
    weth_address,
    usdc_address,
    0f64, // Rest of remaining WETH amount (40%)
);
swap_d = Swap::new(
    pool_d,
    usdc,
    dai,
    0f64, // All of USDC amount
);

let solution = Solution::new(
    user_address.clone(),
    user_address,
    eth_address,       // token_in (ETH — encoder auto-wraps to WETH)
    dai_address,       // token_out
    sell_amount,       // amount_in
    min_amount_out,    // min_amount_out
    vec![swap_a, swap_b, swap_c, swap_d],
);
```

--------------------------------

### Use Tycho Streaming Client

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/python-client

Example of using the TychoStream class to connect to the Tycho Indexer, configure parameters, and stream real-time data. Requires `tycho-indexer-client` package.

```python
import asyncio
from tycho_indexer_client import Chain, TychoStream
from decimal import Decimal

async def main():
    stream = TychoStream(
        tycho_url="localhost:8888",
        auth_token="secret_token",
        exchanges=["uniswap_v2"],
        min_tvl=Decimal(100),
        blockchain=Chain.ethereum,
    )

    await stream.start()

    async for message in stream:
        print(message)

asyncio.run(main())
```

--------------------------------

### Calculate Limits-Based Swap Amounts

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/uniswap-v4-hooks-dci

Example of calculating swap amounts as percentages of a withdrawal limit.

```rust
// Euler provides withdrawal limits from getLimits()
// For token0 → token1 swap with limit = 1000000000000000000 (1e18):
let amounts = [
    10000000000000000,    // 1% = 0.01e18
    100000000000000000,   // 10% = 0.1e18
    500000000000000000,   // 50% = 0.5e18
    950000000000000000,   // 95% = 0.95e18
];
```

--------------------------------

### Install Substreams with Precompiled Binaries

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/1.-setup

Download and extract the latest precompiled Substreams binary for Linux. This method requires `curl` and `tar`.

```bash
# Use correct binary for your platform
LINK=$(curl -s https://api.github.com/repos/streamingfast/substreams/releases/latest | awk '/download.url.*linux/ {print $2}' | sed 's/"//g')
curl -L  $LINK  | tar zxf -
```

--------------------------------

### Simulation output

Source: https://docs.propellerheads.xyz/tycho

Example output showing the results of a successful swap simulation.

```text
Simulating by performing an approval (for permit2) and a swap transaction...

Simulated Block 21944458:
  Transaction 1: Status: true, Gas Used: 46098
  Transaction 2: Status: true, Gas Used: 182743
```

--------------------------------

### Consume Data from Tycho Indexer

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/binary-cli

Example command to track specific protocols with defined filters.

```bash
tycho-client --exchange uniswap_v2 --exchange uniswap_v3 --min-tvl 100 --tycho-url 
tycho-beta.propellerheads.xyz
```

--------------------------------

### Run Slither Analysis

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/contributing-guidelines

Setup a Python environment and execute Slither to perform static analysis on Solidity contracts.

```bash
conda create --name tycho-execution python=3.10
conda activate tycho-execution

pip install slither-analyzer
cd foundry
slither .
```

--------------------------------

### Insufficient balance warning

Source: https://docs.propellerheads.xyz/tycho

Example output displayed when the wallet lacks sufficient funds for the swap.

```text
Your balance: 5.000000 USDC
⚠️ Warning: Insufficient balance for swap. You have 5.000000 USDC but need 10.000000 USDC
Your WETH balance: 1.500000 WETH
```

--------------------------------

### Configure RPCMetadataProvider with Retry Logic

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/uniswap-v4-hooks-dci

Example of configuring the RPCMetadataProvider with custom retry settings, including max retries and backoff durations.

```rust
let retry_config = RPCRetryConfig {
    max_retries: 5,
    initial_backoff_ms: 150,
    max_backoff_ms: 5000,
};

let provider = RPCMetadataProvider::new_with_retry_config(
    50,  // Max batch size
    retry_config,
);
```

--------------------------------

### Use Tycho RPC Client to Fetch Tokens

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/python-client

Example of using the TychoRPCClient to fetch token information from the Tycho Indexer's RPC endpoint. It demonstrates paginating through results to retrieve all tokens matching specific criteria.

```python
from tycho_indexer_client import (
    TychoRPCClient,
    TokensParams,
    Chain,
    PaginationParams
)

client = TychoRPCClient("http://0.0.0.0:4242", chain=Chain.ethereum)

all_tokens = []
page = 0

while True:
    tokens = client.get_tokens(
        TokensParams(
            min_quality=51,
            traded_n_days_ago=30,
            pagination=PaginationParams(page=page, page_size=1000),
        )
    )
    
    if not tokens:
        break
    
    all_tokens.extend(tokens)
    page += 1
```

--------------------------------

### Get Protocol Fee Ratio

Source: https://docs.propellerheads.xyz/tycho/for-solvers/simulation

The `fee` method returns the protocol's fee as a ratio. For example, a 1% fee is returned as 0.01. If the fee is dynamic, this method returns the minimal fee.

```rust
fn fee(&self) -> f64;
```

--------------------------------

### Initialize Adapter Template

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/simulation

Command to create a new adapter directory from the provided template.

```bash
cp ./evm/src/template ./evm/src/<your-adapter-name>
```

--------------------------------

### Create Entrypoint

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/complete-case-study-euler-hooks-external-liquidity-example

Builds the V4Router execute call parameters and action sequence for the swap.

```rust
// Build V4Router execute() call
let pool_key = build_pool_key_from_component(component)?;
let params = ExactInputSingleParams {
    pool_key,
    zero_for_one: true,
    amount_in,
    amount_out_minimum: Bytes::from([0u8]),
    hook_data: Bytes::from([0u8]),
};

let actions = vec![
    V4RouterAction::SWAP_EXACT_IN_SINGLE,
    V4RouterAction::SETTLE_ALL,
];
```

--------------------------------

### Install Tycho Client with Cargo

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/binary-cli

Requires Rust 1.84.0 or later and Cargo installed on the system.

```bash
cargo install tycho-client
```

--------------------------------

### Initialize Bebop RFQ Client

Source: https://docs.propellerheads.xyz/tycho/for-solvers/request-for-quote-protocols

Configure and build a Bebop client instance for streaming prices and requesting quotes.

```rust
let bebop_client = BebopClientBuilder::new(chain, bebop_ws_user, bebop_ws_key)
    .tokens(rfq_tokens)
    .quote_tokens(quote_tokens)
    .tvl_threshold(cli.tvl_threshold)
    .build()
    .expect("Failed to create RFQ clients");
```

--------------------------------

### Build Tycho Adapter Runtime

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/simulation

Execute the build script with specific parameters to generate the runtime file for a new swap adapter.

```bash
>>> cd evm
>>> ./scripts/buildRuntime.sh -c “BalancerV2SwapAdapter” -s “constructor(address)” -a “0xBA12222222228d8Ba445958a75a0704d566BF2C8”
```

--------------------------------

### GET /v1/health

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-rpc

Checks the health status of the Tycho-Indexer RPC service.

```APIDOC
## GET /v1/health

### Description
This endpoint is used to check the health of the service.

### Method
GET

### Endpoint
/v1/health

### Response
#### Success Response (200)
- **status** (string) - The current status of the service (Ready, Starting, or NotReady).
- **message** (string) - Optional status message provided when the service is Starting or NotReady.

#### Response Example
{
  "status": "Ready"
}
```

--------------------------------

### Make Binary Executable and Link

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/3.-testing

Ensure the downloaded Tycho Indexer binary is executable and then create a symbolic link to a directory in your system's PATH.

```bash
// Ensure the binary is executable:
sudo chmod +x tycho-indexer
// Create symlink
sudo ln -s $(pwd)/tycho-indexer /usr/local/bin/tycho-indexer
```

--------------------------------

### Run Solidity Tests

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/contributing-guidelines

Set the RPC URL and execute the test suite using Forge.

```bash
export ETH_RPC_URL=<url>
forge test
```

--------------------------------

### Build and Run Substreams

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/2.-implementation

Compiles the project to WebAssembly and launches the Substreams GUI to verify the protocol changes mapping.

```bash
cd [CHAIN]-[PROTOCOL-SYSTEM]
cargo build --release --target wasm32-unknown-unknown
substreams gui substreams.yaml map_protocol_changes
```

--------------------------------

### Initialize Solution Struct in V2 and V3

Source: https://docs.propellerheads.xyz/tycho/for-solvers/execution/migration-guide-v2-to-v3

Demonstrates the transition from public struct fields in V2 to the constructor and builder pattern in V3.

```rust
// V2
let solution = Solution {
sender: addr,
receiver: addr,
given_token: token_a,
given_amount: amount,
checked_token: token_b,
checked_amount: min_out,
swaps: vec![swap],
exact_out: false,
native_action: Some(NativeAction::Wrap),
};

// V3
let solution = Solution::new(
addr,        // sender
addr,        // receiver
token_a,     // token_in
token_b,     // token_out
amount,      // amount_in
min_out,     // min_amount_out
vec![swap],  // swaps
)
.with_user_transfer_type(UserTransferType::TransferFrom)
.with_client_fee_bps(50)
.with_client_fee_receiver(fee_addr)
.with_max_client_contribution(BigUint::from(0u64));
```

--------------------------------

### Register Exchanges in ProtocolStreamBuilder

Source: https://docs.propellerheads.xyz/tycho/for-solvers/supported-protocols

Example implementation for registering multiple exchange states within a ProtocolStreamBuilder for Ethereum.

```rust
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)
```

--------------------------------

### Create Balance Metadata Request

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/uniswap-v4-hooks-dci

Example of creating a MetadataRequest to fetch token balances using the `getReserves()` function.

```rust
// Generate request to call getReserves() on the hook contract
let balance_request = MetadataRequest {
    request_type: MetadataRequestType::ComponentBalance {
        token_addresses: component.tokens.clone(),
    },
    routing_key: "rpc_default".to_string(),
    generator_name: "euler".to_string(),
    transport: RpcTransport::new(
        rpc_url.clone(),
        "eth_call".to_string(),
        vec![
            json!({
                "to": hook_address,
                "data": "0x0902f1ac" // getReserves() selector
            }),
            json!(format!("0x{:x}", block.number)),
        ],
    ),
};
```

--------------------------------

### Implement V4MiniRouter Pattern

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/uniswap-v4-hooks-dci

Construct a custom router entrypoint with state overrides to simulate Uniswap V4 swaps.

```rust
// 1. Define router address (deterministic)
let router_address = Address::from("0x2626664c2603336E57B271c5C0b26F421741e481");

// 2. Build swap parameters
let pool_key = build_pool_key(component); // Extract from component attributes
let params = ExactInputSingleParams {
    pool_key,
    zero_for_one: true,  // token0 → token1
    amount_in,
    amount_out_minimum: Bytes::from([0u8]),
    hook_data: Bytes::from([0u8]),
};

// 3. Encode V4Router actions
let actions = vec![
    V4RouterAction::SWAP_EXACT_IN_SINGLE,  // Execute swap
    V4RouterAction::SETTLE_ALL,             // Settle input token
    V4RouterAction::TAKE_ALL,               // Take output token
];

let calldata = encode_execute_call(actions, params);

// 4. Set state overrides
let state_overrides = {
    // Deploy router bytecode
    router_address => AccountOverrides {
        code: Some(V4_MINI_ROUTER_BYTECODE),
        ...
    },
    // Set ERC6909 balances in PoolManager
    pool_manager => AccountOverrides {
        slots: erc6909_overwrites(token_in, sender, amount_in),
        ...
    },
    // (Optional) Set ERC20 balances for external tokens
    token_in => AccountOverrides {
        slots: erc20_balance_overwrite(sender, amount_in),
        ...
    },
};

// 5. Create entrypoint
let entrypoint = EntryPointWithTracingParams {
    entry_point: EntryPoint {
        external_id: format!("swap_{token0}_{token1}_{amount_in}"),
        target: router_address,
        signature: "execute(bytes,bytes[])".to_string(),
    },
    params: TracingParams::RPCTracer(RPCTracerParams {
        caller: Some(sender),
        calldata,
        state_overrides: Some(state_overrides),
        prune_addresses: None,
    }),
};
```

--------------------------------

### Create Entry Point and Parameters for DCI

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci

Use this function to create an entry point and its associated tracing parameters for Dynamic Contract Indexing. Ensure the component ID accurately reflects the transaction where the component was created. Add the generated entry point and parameters to the `TransactionChangesBuilder`.

```rust
use tycho_substreams::entrypoint::create_entrypoint;

// defined example trace data
let trace_data = TraceData::Rpc(RpcTraceData{
    caller: None, // None means a default caller will be used
    calldata: "0xabcd123400000000000012345678901234567890", // 0xabcd1234 - function selector, 00000000000012345678901234567890 - input address
});

let entrypoint, entrypoint_params = create_entrypoint(
    target: target_address,
    signature: "getFees(fromAddress)",
    component_id: "pool_id",
    trace_data,
)

// use the TransactionChangesBuilder for the tx where component [pool_id] was created
builder.add_entrypoint(&entrypoint);
builder.add_entrypoint_params(&entrypoint_params);
```

--------------------------------

### Check Tycho Indexer Version

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/3.-testing

Verify that the Tycho Indexer is installed and accessible in your PATH. Ensure the version matches the latest release.

```bash
> tycho-indexer --version
  tycho-indexer 0.88.0 # should match the latest version published on GitHub
```

--------------------------------

### Copy Integration Template

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/2.-implementation

Initializes a new integration directory by copying an existing template and renaming it to match the target chain and protocol.

```bash
cp -r ./substreams/ethereum-template-factory ./substreams/[CHAIN]-[PROTOCOL_SYSTEM]
```

--------------------------------

### Access Tycho CLI Help

Source: https://docs.propellerheads.xyz/tycho/for-solvers/indexer/tycho-client/binary-cli

Display help information for available CLI parameters.

```bash
tycho client --help
```

--------------------------------

### Generate Documentation

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/simulation

Command to generate local documentation for the EVM interfaces.

```bash
cd ./evm/
forge doc
```

--------------------------------

### Aggregate balance changes per transaction

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/normalizing-relative-erc20-balances

Example of associating absolute balances with transactions and components for final protocol change mapping.

```rust
#[substreams::handlers::map]
pub fn map_protocol_changes(
    block: eth::v2::Block,
    grouped_components: BlockTransactionProtocolComponents,
    deltas: BlockBalanceDeltas,
    components_store: StoreGetInt64,
    balance_store: StoreDeltas,
) -> Result<BlockChanges> {
    let mut transaction_contract_changes: HashMap<_, TransactionChanges> = HashMap::new();

    aggregate_balances_changes(balance_store, deltas)
        .into_iter()
        .for_each(|(_, (tx, balances))| {
            transaction_contract_changes
                .entry(tx.index)
                .or_insert_with(|| TransactionChanges::new(&tx))
                .balance_changes
                .extend(balances.into_values());
        });
}
```

--------------------------------

### Swap action prompt

Source: https://docs.propellerheads.xyz/tycho

Interactive menu for choosing between simulation, execution, or skipping the swap.

```text
Would you like to simulate or execute this swap?
Please be aware that the market might move while you make your decision, which might lead to a revert if you've set a min amount out or slippage.
Warning: slippage is set to 0.25% during execution by default.

? What would you like to do? ›
❯ Simulate the swap
  Execute the swap
  Skip this swap
```

--------------------------------

### Callback Interface

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/execution

Interface for protocols that require a callback during swap execution. Includes methods for handling, verifying, and getting transfer data for callbacks.

```APIDOC
## Callback Interface

### Description
Interface for protocols that require a callback during swap execution. Includes methods for handling, verifying, and getting transfer data for callbacks.

### Methods

#### `handleCallback`
```solidity
function handleCallback(bytes calldata data) external returns (bytes memory result);
```
**Description:** The main entry point for handling callbacks. Executes the necessary logic to complete the swap interaction after a protocol-initiated callback.

#### `verifyCallback`
```solidity
function verifyCallback(bytes calldata data) external view;
```
**Description:** Verifies that the `msg.sender` is a valid pool from the expected protocol. Should be called within `handleCallback`.

#### `getCallbackTransferData`
```solidity
function getCallbackTransferData(bytes calldata data) external payable returns (TransferManager.TransferType transferType, address receiver, address tokenIn, uint256 amountIn);
```
**Description:** Called by the Dispatcher during the callback to determine how tokens should be transferred. The transfer type must be hardcoded.

### Callback Flow
When a protocol initiates a callback, it flows through the `TychoRouter`'s `fallback()` method, which delegates to the Dispatcher. The Dispatcher then calls `getCallbackTransferData` on the executor, performs the token transfer, and finally calls `handleCallback` on the executor.
```

--------------------------------

### Generate Metadata Requests for Protocol Components

Source: https://docs.propellerheads.xyz/tycho/for-dexs/protocol-integration/indexing/common-problems-and-patterns/dynamic-contract-indexing-dci/hook-integration-guide

Example of constructing RPC transport requests for eth_call, including optional state overrides for contract interaction.

```rust
                    request_type: MetadataRequestType::Limits {
                        token_pair: token_pair.clone(),
                    },
                    routing_key: "rpc_default".to_string(),
                    generator_name: "my_hook".to_string(),
                    transport: RpcTransport::new(
                        self.rpc_url.clone(),
                        "eth_call".to_string(),
                        vec![
                            json!({
                                "to": "YOUR_CONTRACT_ADDRESS",
                                "data": "YOUR_CALLDATA",
                            }),
                            json!(format!("0x{:x}", block.number)),
                            // Optional: state overrides
                            // json!({ "address": { "code": "0x...", "state": {...} } }),
                        ],
                    ),
                });
            }
        }

        Ok(requests)
    }
}
```
Tokens:
Raw