Clients

Tycho Client streams protocol state changes to you.

Tycho Client is available as a Python package and a Rust crate.

Key Features

• Real-Time Streaming: Access live protocol data with low-latency updates allowing you to stay in sync with the latest protocol changes as they happen.

• Protocol-Specific Insights: Automatically discover new pools and their tokens as they’re created.

• Active TVL Filtering: Focus on the most impactful data by setting Total Value Locked (TVL) thresholds. The client actively filters on your behalf, so you receive updates only on the pools that meet your specified thresholds and notices for pools that no longer do.

---

Getting Started

Ready to dive in? This guide will walk you through the simple steps to set up and use the Tycho Client, whether you prefer the CLI Binary, Rust Crate, or Python Package. Follow along to stream your protocol data.

CLI Binary

For a simple, setup-free start: download the latest binary release on GitHub, add it to your PATH, and verify installation with:

tycho-client -V

You should see the Tycho client version displayed. If you need more guidance, refer to our detailed installation instructions.

Now, define the pools you want to track: For example, to track the Uniswap V2 and V3 pools with a minimum value locked of 100 ETH, run:

tycho-client --exchange uniswap_v2 --exchange uniswap_v3 --min-tvl 100 --tycho-url {TYCHO_INDEXER_URL}

Authentication

For services where authentication is required, you can do this securely by setting an environment variable for your token:

export TYCHO_AUTH_TOKEN={your_token}

Or skip secure connections entirely with --no-tls for local setups [coming soon].

Help and More Information

For more details on using the CLI, run:

tycho client --help

Rust Crate

The rust crate provides a flexible library for developers to integrate Tycho’s real-time data into any Rust application.

To use Tycho Client in Rust, add the crate to your Cargo.toml:

[dependencies]
tycho-client = "0.35.3"

From there it is easy to add a Tycho stream to your rust program like so:

use tycho_core::dto::Chain;
use tycho_client::{stream::TychoStreamBuilder, feed::component_tracker::ComponentFilter};

let receiver = TychoStreamBuilder::new("localhost:4242", Chain::Ethereum)
    .auth_key(Some("my_api_key".into()))
    .exchange("uniswap_v2", ComponentFilter::with_tvl_range(10.0, 15.0))
    .exchange(
        "uniswap_v3",
        ComponentFilter::Ids(vec![
            "0xCBCdF9626bC03E24f779434178A73a0B4bad62eD".to_string(),
            "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640".to_string(),
        ]),
    )
    .build()
    .await
    .expect("Failed to build tycho stream");

For more information see the tycho-client documentation.

Python Package

A python package is available to ease integration into python-based projects. To install locally:

1. Build the package:

   pip install maturin
   python -m maturin build --release

2. Install the package:

   pip install <path/to/your_package.whl>

Once installed, start streaming Tycho messages seamlessly. See here an example quick setup:

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())

For more details on the python package see the tycho-client-py documentation.

---

Clear, Actionable Data in Real-Time

Tycho emits data in an easy-to-read JSON format. Get granular updates on each block:

• Snapshots for complete component (or pool) states,

• Deltas for specific updates, and

• Removal notices for components that no longer match your filtration criteria.

Each message includes block details to help you stay on track with the latest block data.

For specifics on the message structures and their intended uses, see our tycho-client documentation.

---

Harness the Power of Tycho's RPC

The client packages above not only stream live data to you, but also provide you access to Tycho’s RPC, where you can query token and protocol data as you need it.

Key Capabilities:

• s.

• Token information: Query tokens that Tycho supports, and filter by e.g. days since the token was last traded or token type, so you can quickly identify the assets most relevant to you.

Here's an example demonstrating fetching tokens from Tycho:

Rust

use tycho_client::rpc::HttpRPCClient;
use tycho_core::dto::Chain;

let client = HttpRPCClient::new("insert_tycho_url", Some("my_auth_token"));

let tokens = client
    .get_all_tokens(
        Chain::Ethereum,
        Some(51_i32), // min token quality to filter for certain token types
        Some(30_u64), // number of days since last traded
        1000,         // pagination chunk size
    )
    .await
    .unwrap();
    
/// Token quality is between 0-100, where:
///  - 100: Normal token
///  - 75: Rebase token
///  - 50: Fee token
///  - 10: Token analysis failed at creation
///  - 5: Token analysis failed on cronjob (after creation).
///  - 0: Failed to extract decimals onchain

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

---

Hosted Tycho: Try Our Beta Service

You don't need to host Tycho yourself.

Get beta access to our hosted Tycho service. Message @tanay_j on Telegram to contact us.

---

Learn More and Get Started

Ready to dive deeper? For a detailed guide on using Tycho Indexer, including setup and customization options, visit the full documentation in our GitHub repository.