Tycho
  • Quickstart
  • Overview
  • Motivation
  • Concepts
  • How to Contribute
    • Bounties
  • For Solvers
    • Indexer
      • Tycho RPC
      • Tycho Client
        • Binary / CLI
        • Rust Client
        • Python Client
    • Simulation
    • Execution
      • Encoding
      • Executing
      • Contract Addresses
      • Execution Venues
    • Hosted Endpoints
    • Supported Protocols
  • For DEXs
    • Protocol Integration
      • Indexing
        • 1. Setup
        • 2. Implementation
        • 3. Testing
          • How to Run
        • Common Problems & Patterns
          • Tracking Components
          • Tracking Contract Storage
          • Normalizing relative ERC20 Balances
          • Tracking Contract Balances
          • Custom protobuf models
        • Best Practices
        • Reserved Attributes
      • Simulation
        • Ethereum: Solidity
      • Execution
        • Code Architecture
      • Contributing guidelines
Powered by GitBook
On this page
  • What is Tycho?
  • Ending the integration nightmare
  • Get started
  • Solvers – Access more liquidity
  • DEXs – Get more flow
  • Components of Tycho
  • FAQ
Export as PDF

Overview

Overview of Tycho, its components and how to get started.

PreviousQuickstartNextMotivation

Last updated 3 months ago

What is Tycho?

Tycho is an open-source interface to on-chain liquidity. Tycho

  • Indexes DEX protocol state for you with low latency,

  • Simulates swaps extremely fast with one interface for all DEXs, and

  • Executes swaps on-chain

Ending the integration nightmare

Integrations are the largest point of friction for both DEXs and Solvers:

  • Solvers can't scale integrations. So, Solvers spend much of their time on integrations, and new solvers can't catch up and compete.

  • DEXs need to convince solvers to integrate them to get orderflow and win LPs. But Solvers prioritize DEXs with liquidity. This makes it hard for new DEXs to get the flow their design deserves.

In the end, every solver separately integrates every DEX – leading to massive wasted effort from which no one benefits.

Tycho fixes this:

  • DEXs can integrate themselves and don't need to wait for solvers, and

  • Solvers can use new DEXs without any additional effort.

Tycho lowers barriers to entry so that both innovative DEXs and Solvers have a chance to win flow.

Get started

Solvers – Access more liquidity

Tycho makes it easy to simulate and execute over on-chain liquidity sources – without needing to understand protocol internals, run nodes, or do RPC calls.

To set up, go to the Tycho Indexer quickstart and start your liquidity stream.

DEXs – Get more flow

To integrate your DEX, submit a PR to Tycho Protocol Integrations on GitHub.

To get started, check the Protocol SDK docs.

Or contact our team so we can help you integrate.

Components of Tycho

Tycho has three components for solvers:

  • Tycho Indexer: Infrastructure to parse, store and stream protocol state deltas. It also comes with clients in Python and Rust and a hosted webstream if you don't want to run your version of the Indexer. -> Indexer docs.

  • Tycho Protocol Simulation: A simulation library with a unified interface to query swaps and prices. Optimized for speed, running on compiled contracts in REVM with in-memory storage. -> Protocol Simulation docs.

  • Tycho Execution: Audited and gas-efficient router and DEX executor contracts for safe, simple, and competitive execution of swaps.

And one integration SDK for DEXs:

  • Tycho Protocol Integration: An SDK for any DEX (or Stable Coin, LRT, etc.) to integrate their liquidity and receive flow from solvers.

FAQ

How does Tycho compare to just parsing logs myself?

While you can parse logs directly, Tycho provides parsed, and structured data, offers a unified interface across protocols, manages reorgs automatically, can handle protocols that don't emit logs and saves you the infrastructure cost of running a node.

Does this add gas to my swaps?

No it does not. Tycho contracts make it easy to simulate a DEX correctly for your swaps. But you can still execute the swaps directly with the DEX – as gas efficient as possible.

How do you handle reorgs?

Reorgs are handled automatically through our delta system. The client maintains the correct state without you having to worry about block reorganizations.

How does latency compare to other solutions?

Tycho processes updates in under 100ms (plus network latency). While an additional hop compared to running your own nodes, geographically distributed nodes race to provide data, which can be faster than relying on a single node.

Can I still use my own UniV2/V3 implementations?

Yes! Many teams use Tycho VM for newer/complex protocols while keeping their analytical implementations for simpler pools.

What about UniV4 hooks?

We aim to support as many hooks variants as possible through our VM implementation.

What's the difference between Native and VM implementations?

Native implementations provide protocol-specific state variables directly, letting you implement your own math and optimizations. VM implementations provide a unified interface through REVM, making integration easier but with less low-level control. Choose based on your needs. Native for maximum control, VM for easier integration.

How reliable is the state data?

The system handles reorgs automatically, keeps track of TVL changes, and maintains consistency across state updates. The data is synced against on-chain state and continuously validated.