• Getting Started
  • How To Get Kelp
    • Download Kelp Binary
    • Compile from Source
  • Running Kelp
  • Using CCXT
    • Download CCXT Binary
    • Run CCXT using Docker
  • Using Postgres
  • Be Smart and Go Slow
• Components
  • Strategies
  • Price Feeds
  • Configuration Files
  • Exchanges
  • Plugins
  • Directory Structure
  • Accounting
• Examples
  • Walkthrough Guides
  • Configuration Files
• Changelog
• Community
  • Contributing
  • Communication
  • Code of Conduct
  • Project Improvements
• Public Assets

Note for Windows Users: You should use a Bash Shell to follow the steps below. This will give you a UNIX environment in which to run your commands and will enable the ./scripts/build.sh bash script to work correctly.

To compile Kelp from source:

1. Download and setup Golang v1.13 or later.
2. Install Glide for dependency management
   • curl https://glide.sh/get | sh
3. Install Yarn and NodeJs to build the Kelp GUI
4. Clone the repo into $GOPATH/src/github.com/stellar/kelp:
   • git clone [email protected]:stellar/kelp.git
5. Change to the kelp directory and install the dependencies:
   • glide install
6. Install the astilectron-bundler binary in a folder that is in your PATH
7. Build the binaries using the provided build script (the go install command will produce a faulty binary):
   • ./scripts/build.sh
8. Confirm one new binary file:
   • ./bin/kelp
9. Set up CCXT to use an expanded set of priceFeeds and orderbooks (see the Using CCXT section for details)
   • sudo docker run -p 3000:3000 -d franzsee/ccxt-rest:v0.0.4

The CCXT-REST server must be running on port 3000 before you start up the Kelp bot. You can list the exchanges (./kelp exchanges) to get the full list of supported exchanges via CCXT.

Note: this integration is still experimental and is also incomplete. Please use at your own risk.

CCXT-rest can be run in any one of the following ways.

We have compiled the ccxt-rest v0.0.4 server as a binary for all x86 platforms (linux, darwin, windows). This is the version that Kelp currently uses.

You can find these pre-compiled binaries of the CCXT-rest server in the releases tab here.

Install docker (linux: sudo apt install -y docker.io) and run the CCXT-REST docker image configured to port 3000 (linux: sudo docker run -p 3000:3000 -d franzsee/ccxt-rest:v0.0.4). You can find more details on the CCXT_REST github page.

Postgres must be installed for Kelp to automatically write trades to a sql database along with updating the trader config file.

Strategies are at the core of Kelp. Without them it's just lazy, capable of nothing, thinking of nothing, doing nothing, like our friend scooter here. The strategies give your bot purpose. Each approaches the market in a different way and is designed to achieve a particular goal.

The following strategies are available out of the box with Kelp:

• sell (source):

  • What: creates sell offers based on a reference price with a pre-specified liquidity depth
  • Why: To sell tokens at a fixed price or at a price that changes based on an external reference price
  • Who: An issuer could use Sell to distribute tokens from an ICO pre-sale
  • Complexity: Beginner

• sell_twap (source):

  • What: creates sell offers based on a reference price spread over the day for a given daily sale amount
  • Why: To sell tokens consistently using the time-weighted-average-price (TWAP) metric
  • Who: An issuer could use SellTwap to distribute tokens from an ICO pre-sale in a consistent manner
  • Complexity: Intermediate

• buysell (source):

  • What: creates buy and sell offers based on a specific reference price and a pre-specified liquidity depth while maintaining a spread.
  • Why: To make the market for tokens based on a fixed or external reference price.
  • Who: Anyone who wants to create liquidity for a stablecoin or fiat token
  • Complexity: Beginner

• balanced (source):

  • What: dynamically prices two tokens based on their relative demand. For example, if more traders buy token A from the bot (the traders are therefore selling token B), the bot will automatically raise the price for token A and drop the price for token B. This strategy does not allow you to configure the order size but can run out of assets. This is a mean-reversion strategy.
  • Why: To let the market surface the true price for one token in terms of another.
  • Who: Market makers and traders for tokens that have a neutral view on the market
  • Complexity: Intermediate

• pendulum (source):

  • What: dynamically prices two tokens based on their relative demand. For example, if more traders buy token A from the bot (the traders are therefore selling token B), the bot will automatically raise the price for token A and drop the price for token B. This strategy allows you to configure the order size but runs the risk of running out of one of the two assets. This is a mean-reversion strategy.
  • Why: To let the market surface the true price for one token in terms of another.
  • Who: Market makers and traders for tokens that have a neutral view on the market
  • Complexity: Beginner

• mirror (source):

  • What: mirrors an orderbook from another exchange by placing the same orders on Stellar after including a spread.
  • Why: To hedge your position on another exchange whenever a trade is executed to reduce inventory risk while keeping a spread
  • Who: Anyone who wants to reduce inventory risk and also has the capacity to take on a higher operational overhead in maintaining the bot system.
  • Complexity: Advanced

• delete (source):

  • What: deletes your offers from both sides of the specified orderbook. Note: does not need a strategy-specific config file.
  • Why: To kill the offers placed by the bot. This is not a trading strategy but is used for operational purposes only.
  • Who: Anyone managing the operations of the bot who wants to stop all activity by the bot.
  • Complexity: Beginner

Price Feeds fetch the price of an asset from an external source. The following price feeds are available out of the box with Kelp:

• crypto: fetches the price of tokens from CoinMarketCap
• fiat: fetches the price of a fiat currency from the CurrencyLayer API
• exchange: fetches the price from an exchange you specify, such as Kraken or Poloniex. You can also use the CCXT integration to fetch prices from a wider range of exchanges (see the Using CCXT section for details)
• fixed: sets the price to a constant
• function: uses a pre-defined function to combine the above price feed types into a single feed. We currently support only two types
  • max - max(exchange/ccxt-binance/XLM/USDT/mid,exchange/ccxt-coinbasepro/XLM/USD/mid)
  • invert - invert(exchange/ccxt-binance/XLM/USDT/mid)

• sdex ("sdex") (source): The Stellar Decentralized Exchange
• kraken ("kraken") (source): Kraken - recommended to use ccxt-kraken instead
• kraken (via CCXT) ("ccxt-kraken") (source): Kraken via CCXT - full two-way integration (tested)
• binance (via CCXT) ("ccxt-binance") (source): Binance via CCXT - full two-way integration (tested)
• coinbasepro (via CCXT) ("ccxt-coinbasepro") (source): Coinbase Pro via CCXT - full two-way integration (tested)
• poloniex (via CCXT) ("ccxt-poloniex") (source): Poloniex via CCXT - only tested on priceFeeds and one-way mirroring
• bittrex (via CCXT) ("ccxt-bittrex") (source): Bittrex via CCXT - only tested on priceFeeds and onw-way mirroring

Kelp can easily be extended because of its modular plugin based architecture. You can create new flavors of the following components: Strategies, PriceFeeds, and Exchanges.

These interfaces make it easy to create plugins:

• Strategy (source) - API for a strategy
• PriceFeed (source) - API for price of an asset
• Exchange (source) - API for crypto exchanges

The folders are organized to make it easy to find code and streamline development flow. Each folder is its own package without any sub-packages.

github.com/stellar/kelp
├── api/            # API interfaces live here (strategy, exchange, price feeds, etc.)
├── cmd/            # Cobra commands (trade, exchanges, strategies, etc.)
├── examples/       # Sample config files and walkthroughs
├── model/          # Low-level structs (dates, orderbook, etc.)
├── plugins/        # Implementations of API interfaces (sell strategy, kraken, etc.)
├── support/        # Helper functions and utils
├── trader/         # Trader bot logic; uses other top-level packages like api, plugins, etc.
├── glide.yaml      # Glide dependencies
├── main.go         # main function for our kelp binary
└── ...

TEST1 and TEST2 issued by the GCL4KBYTRA3QYI4JTN4FWVYVYNI67W2M6XMDUB2V6ZLWFASIYHWEJPHU account are test assets used to test Kelp on the production Stellar Network. These assets have no value and are marked as auth_required with the intent to close them off from the rest of the Stellar ecosystem. No trustlines will be accepted against these assets. As part of our testing process, you may observe a market and trades between these two tokens. It is not intended for any of these assets to represent any meaningful volume on the Stellar Network.