Capy Trading Bot

This repository contains simple DeFi bots in Typescript, which are designed to find and take advantage of arbitrage opportunities in different SUI DEXs and/or perform trading activities based on script-logic strategies. Since it is still in BETA version, the agents might not be profitable and are mainly open-sourced as a reference implementation that could be reused to implement custom strategies.

Features

• Implements a basic Strategy interface (developers can implement their own strategies).
• Provides three basic trading strategies as reference implementations (described later in this Readme).
• Automatically executes trades when it finds profitable opportunities.
• Supports multiple cryptocurrencies and trading pairs; currently supporting trading on three Sui DEXs.
• Supports receiving data from multiple sources, including swap pools and external sources like Binance. Currently, the bot utilizes feeds from CCTX (CryptoCurrency eXchange Trading Library) to get the latest prices from Binance. Note that CCTX supports Binance, Bitget, Coinbase, Kraken, KuCoin and OKX, and it is straight-forward to accept feeds from these CEXs as well.

Overview

In Capy Trading Bot, strategies subscribe to relevant data sources and create trade orders based on the information they get. Every second, Capy Trading Bot requests new data points from each data source. When it receives a new data point, Capy Trading Bot sends it to subscribing strategies which return trade orders to Capy Trading Bot. Capy Trading Bot submits transactions to the relevant swap pools modules to execute these trade orders. If a strategy returns multiple trade orders, Capy Trading Bot submits them as a single transaction.

sequenceDiagram
    Strategy->>Capybot: Subscribe to relevant data sources
    activate Capybot
    loop Every second for each data source
        Capybot->>+DataSource: Request new data point
        DataSource->>DataSource: Call external API
        DataSource->>-Capybot: New data point
        loop For each subscribing strategy
            Capybot->>+Strategy: New data point
            Strategy->>-Capybot: Trade orders
            Capybot->>Capybot: Submit trade orders as a single transaction block
        end
    end
    deactivate Capybot

Strategies

Capy Trading Bot supports the following three trading strategies:

• Arbitrage: This strategy looks for arbitrage opportunities in chains of two or more swap pools across different DEXs. It computes the product of the prices along the chain of swap pools, say SUI -> USDC -> CETUS -> SUI, and if the product is different from 1 it means there is an arbitrage opportunity.
• RideTheTrend: This strategy looks for trend following opportunities in a single swap pool by comparing a short moving average with a longer moving average to get an indication whether the price is going up or down.
• MarketDifference: This strategy compares the relative price of a token pair in a swap pool with the price of the same pair on an exchange, such as Binance. If the price differs, the strategy suggests to either go long or short a given token.

Strategies are located in the src/strategies folder, and each strategy extends the Strategy class which requires the evaluate method to be implemented. The evaluate method is called every second with the latest data point from the data sources and should return a (potentially empty) array of trade orders.

To add other strategies, you can implement them as described above and add it to Capy Trading Bot by calling capybot.addStrategy in src/index.ts.

Data sources

Capy Trading Bot can leverage two different types of data sources: Swap pools and external sources. Capy Trading Bot can execute trades via swap pools, and swap pools provide the current token price in the pool. External data sources can provide additional data that could be useful inputs to trading strategies.

In this release, Capy Trading Bot supports swap pools from Cetus, Turbos and Suiswap, and uses Binance (via CCTX) as an external data source for the relative prices of some token pairs.

Installation

1. Clone this repository.
2. Install dependencies with npm install.

Usage

Set two environment variables

Before you run the script, you need to set two environment variables: ADMIN_PHRASE and ADMIN_ADDRESS. The ADMIN_PHRASE is the passphrase for your account, and the ADMIN_ADDRESS is the hexadecimal address of your account. You can export them using the following commands in your terminal:

export ADMIN_PHRASE="your_passphrase_here"
export ADMIN_ADDRESS="your_address_here"

Before you continue with the next steps, make sure to replace the placeholders with your actual values. Do not share your passphrase or address with anyone else.

Declare Pools

On the following snippet of code, we declare 3 pools

const USDCtoSUI = new Pool("0x0...1", coins.USDC, coins.SUI);

const USDTtoSUI = new Pool("0x0...2", coins.USDT, coins.SUI);

const USDCtoUSDT = new Pool("0x0...3", coins.USDC, coins.USDT);

Add a triangular arbitrage strategy

To execute a triangular arbitrage strategy, a trader makes 3 transactions: first, exchange the original token for another one (i.e. SUI -> USDC); second, swap the second token for a third one (i.e. USDC -> USDT); and third, trade the third token back to the original one (i.e. USDT -> SUI).

On the following snippet of code we add a triangular arbitrage strategy to the capybot.

// Add triangular arbitrage strategy: USDC/SUI -> (USDT/SUI)^-1 -> (USDC/USDT)^-1.
capybot.addStrategy(
  new Arbitrage(
    [
      {
        pool: SUItoUSDC.uri,
        a2b: true,
      },
      {
        pool: USDCtoUSDT.uri,
        a2b: true,
      },
      {
        pool: USDTtoSUI.uri,
        a2b: true,
      },
    ],
    defaultAmount[coins.SUI],
    ARBITRAGE_RELATIVE_LIMIT,
    "Arbitrage: SUI -> USDC -> USDT -> SUI"
  )
);

ARBITRAGE_RELATIVE_LIMIT represents the relative limit. e.g. 1.05 for a 5% win.

Add a ride the trend strategy

Ride the trend strategy is a trading technique that involves following the direction of the market movement and staying in a position until the trend reverses. The idea is to capture as much profit as possible from a strong and sustained price movement. To apply this strategy, traders need to identify the trend using technical indicators, such as moving averages and enter a trade when the price confirms the trend.

On the following snippet of code, we add a Ride The Trend strategy to the capybot.

capybot.addStrategy(
  new RideTheTrend(
    SUItoUSDC.uri,
    5,
    10,
    [defaultAmount[SUItoUSDC.coinTypeA], defaultAmount[SUItoUSDC.coinTypeB]],
    RIDE_THE_THREAD_LIMIT,
    "RideTheTrend (SUI/USDC)"
  )
);

It takes six parameters as input:

• pool: The address of the pool to watch.
• short: The length of the short moving average (in seconds).
• long: The length of the long moving average (in seconds).
• defaultAmounts: An array of two numbers, representing the amount of tokens to swap of coin type A and B respectively when the trend changes.
• limit: A number between 0 and 1, representing the percentage of profit or loss to accept before executing a swap. For example, 1.05 means a 5% profit margin.
• name: A human-readable name for this strategy.

It calculates the moving averages of the pool price and it then compares the short and long moving averages to determine the trend direction. When the trend changes, it executes a swap, with the specified swap amounts and relative limit.

Market Difference

The bot can also use external data sources. For example, if there is a price discrepancy between Binance and a SUI DEX, the bot can arbitrage by buying/selling tokens on the DEX.

On the following snippet of code, we create a new market difference strategy. This strategy compare prices between a pool and various exchanges and will buy the token that is too cheap and sell the token that is too expensive.

capybot.addStrategy(
  new MarketDifference(
    WBTCtoUSDC,
    "BinanceBTCtoUSDC",
    [defaultAmount[coins.WBTC], defaultAmount[coins.USDC]],
    ARBITRAGE_RELATIVE_LIMIT,
    "Market diff: (W)BTC/USDC, Binance vs DEX"
  )
);

The following parameters are required:

• pool: The pool to monitor for price changes.
• exchange: The exchange to compare with the pool. It should offer the same trading pairs as the pool.
• defaultAmounts: The default amounts of tokens to trade when the price difference exceeds the limit.
• limit: The relative threshold for the price difference. A trade will be executed if the price difference is greater than this value.
• For example, a value of 1.05 means that the price difference should be at least 5%.
• name: A human-readable name for this strategy.

Build and Run the Bot

Build the project with npm run build

Run the script with npm run start

This will run the bot for one hour. To run the bot for longer you should change the duration value in the call to capybot.loop in src/index.ts.

Monitoring

The Capybot Monitor is a collection of Python scripts to monitor the status of a running instance of a Capybot. It produces live updated plots like the following which shows the price development for the swap pools the given Capybot was trading where 1 is the price when the bot was started.

Installation instructions are available on the Capybot Monitor repository.

Pools

The table below lists all the pools for the 3 DEXs:

Contributing

Contributions are welcome! Please open an issue or pull request if you have any suggestions or improvements.