How to Build a Drift Protocol Perps Trading Bot

Pro Tip Before Anything Else… Get a better RPC!

Ultimately the performance you have with any programmatic Solana trading hinges on having a server that’s fast, and geographically nearby a bunch of Solana validators and the server you’re running your bot on.

I’ve been using Chainstack and I am able to use their RPC server in London, I have my VPS on Amazon Lightsail in the London region, and there are many Solana validators also running in that region as well.

These AMAZING PEOPLE offer a private provisioned Solana RPC with up to 250 requests per second, for $1 for your first month. And only $49 a month after that. And then just $349 for a dedicated node. And it’s good. I mean, like REAL good. It just works.

Please use our special shiny referral link and support docs.wtf for all your documentation and wtf-related needs.

Table of Contents

1. Understanding Key Concepts
2. Setting Up Your Development Environment
3. Implementing Dynamic Priority Fees
4. Creating the Basic Bot Structure
5. Implementing Core Trading Functionality
6. Adding Position Management
7. Running and Testing Your Bot
8. Advanced Features and Considerations
9. Conclusion and Next Steps

Understanding Key Concepts

Before we dive into coding, let’s review some important concepts:

Priority Fees

Also known as compute unit prices in Solana, priority fees are used to prioritize transaction processing during congested network conditions.

Dynamic adjustment of these fees is crucial for optimal bot performance.

Precision and Big Numbers

Cryptocurrencies often deal with very small fractions, requiring high precision, so most platforms use the BN (Big Number) library for precise calculations.

The @drift-labs/sdk library provides the following constants

• PRICE_PRECISION
• BASE_PRECISION
• QUOTE_PRECISION

When used with BN, you can convert to the proper precisions required for Drift perps orders. For example:

const priceBN = new BN(examplePrice * PRICE_PRECISION);

This converts the human readable price (ex. 123.4567) to BN at the proper precision for your order.

Note

IMPORTANT: Order Precision is CRUCIAL for successful transactions and fast fill times. If it’s not working, check your precisions and make sure you’re using BN (or a Drift function that does the BN conversion for you, such as driftClient.convertToPerpPrecision).

Order Types

• Market Orders: Execute immediately at the best available price.
• Limit Orders: Execute only at a specified price or better.
• Trigger Orders: Activate when a certain price condition is met.

Long vs Short

• Going Long: Buying an asset, expecting its price to rise.
• Going Short: Selling an asset you don’t own, expecting its price to fall.

Take-Profit and Stop-Loss

• Take-Profit (TP): An order to automatically close a position when a certain profit level is reached.
• Stop-Loss (SL): An order to automatically close a position when a certain loss level is reached.

Setting Up Your Development Environment

Before we start coding, let’s set up our development environment:

1. Install Node.js (version 14 or higher) from nodejs.org.
2. Open your terminal or command prompt.
3. Create a new directory for your project:

mkdir drift-trading-bot
cd drift-trading-bot

4. Initialize a new Node.js project:

npm init -y

5. Install the necessary dependencies:

npm install @solana/web3.js @drift-labs/sdk dotenv axios

6. Create a new file named bot.js in your project directory. This will be the main file for our trading bot.

Implementing Dynamic Priority Fees

Dynamic priority fees are crucial for optimal bot performance.

We recommend using a Helius RPC to take advantage of their specialized priority fee api.

They offer a free plan that works perfectly to fetch real-time priority fee estimates.

Add this method to your TradingBot class:

async updatePriorityFee() {
  try {
    const response = await axios.get(this.heliusUrl);
    const priorityFees = response.data;

    const highPriorityFee = priorityFees.find(fee => fee.priorityLevel === 'high');

    if (highPriorityFee) {
      this.currentPriorityFee = highPriorityFee.priorityFeeEstimate;
      console.log(`Updated priority fee to: ${this.currentPriorityFee}`);
    } else {
      console.log('Failed to get priority fee estimate from Helius');
    }
  } catch (error) {
    console.error(`Error updating priority fee: ${error.message}`);
  }
}

This method fetches the latest priority fee estimates from Helius and updates our bot’s currentPriorityFee. We’re using the “high” priority level to ensure our transactions are processed quickly.

Creating the Basic Bot Structure

Now, let’s set up the basic structure of our bot. Open your bot.js file and add the following code:

const { Connection, PublicKey } = require("@solana/web3.js");
const {
  DriftClient,
  initialize,
  OrderType,
  PositionDirection,
  OrderTriggerCondition,
  MarketType,
  PostOnlyParams,
  BN,
  PRICE_PRECISION,
  BASE_PRECISION,
  QUOTE_PRECISION
} = require("@drift-labs/sdk");
const axios = require('axios');
require('dotenv').config();

class TradingBot {
  constructor() {
    this.driftClient = null;
    this.user = null;
    this.currentPriorityFee = 50_000; // Default priority fee
    this.priorityFeeUpdateInterval = 120000; // Update every 2 minutes
    this.heliusUrl = `https://api-mainnet.helius.xyz/v0/priority-fee?api-key=${process.env.HELIUS_API_KEY}`;
  }

  async initialize() {
    console.log("Initializing bot...");

    const connection = new Connection(process.env.RPC_ENDPOINT);
    const wallet = initialize({ privateKey: process.env.PRIVATE_KEY });

    this.driftClient = new DriftClient({
      connection,
      wallet,
      programID: new PublicKey(process.env.DRIFT_PROGRAM_ID),
    });

    await this.driftClient.subscribe();
    this.user = await this.driftClient.getUser();
    await this.user.subscribe();

    console.log("Bot initialized successfully");
  }

  // We'll add more methods here
}

module.exports = TradingBot;

This code sets up the basic structure of our TradingBot class and initializes the connection to the Drift protocol.

Implementing Core Trading Functionality

Now, let’s add methods to place different types of orders. Add these methods to your TradingBot class:

async placeMarketOrder(marketIndex, direction, size) {
  const orderParams = {
    orderType: OrderType.MARKET,
    marketIndex,
    marketType: MarketType.PERP,
    direction: direction === "long" ? PositionDirection.LONG : PositionDirection.SHORT,
    baseAssetAmount: new BN(size * BASE_PRECISION),
  };

  try {
    const tx = await this.driftClient.placeOrder(orderParams, {
      computeUnitsPrice: this.currentPriorityFee
    });
    console.log(`Market order placed. Transaction: ${tx}`);
  } catch (error) {
    console.error(`Error placing market order: ${error.message}`);
  }
}

async placeLimitOrder(marketIndex, direction, size, price) {
  const orderParams = {
    orderType: OrderType.LIMIT,
    marketIndex,
    marketType: MarketType.PERP,
    direction: direction === "long" ? PositionDirection.LONG : PositionDirection.SHORT,
    baseAssetAmount: new BN(size * BASE_PRECISION),
    price: new BN(price * PRICE_PRECISION),
    postOnly: PostOnlyParams.SLIDE,
  };

  try {
    const tx = await this.driftClient.placeOrder(orderParams, {
      computeUnitsPrice: this.currentPriorityFee
    });
    console.log(`Limit order placed. Transaction: ${tx}`);
  } catch (error) {
    console.error(`Error placing limit order: ${error.message}`);
  }
}

async placeTriggerMarketOrder(marketIndex, direction, size, triggerPrice, triggerCondition) {
  const orderParams = {
    orderType: OrderType.TRIGGER_MARKET,
    marketIndex,
    marketType: MarketType.PERP,
    direction: direction === "long" ? PositionDirection.LONG : PositionDirection.SHORT,
    baseAssetAmount: new BN(size * BASE_PRECISION),
    triggerPrice: new BN(triggerPrice * PRICE_PRECISION),
    triggerCondition: triggerCondition === "above" ? OrderTriggerCondition.ABOVE : OrderTriggerCondition.BELOW,
  };

  try {
    const tx = await this.driftClient.placeOrder(orderParams, {
      computeUnitsPrice: this.currentPriorityFee
    });
    console.log(`Trigger market order placed. Transaction: ${tx}`);
  } catch (error) {
    console.error(`Error placing trigger market order: ${error.message}`);
  }
}

Let’s break down these methods:

• placeMarketOrder: This method places a market order, which executes immediately at the best available price. It’s useful when you need to enter or exit a position quickly, but be aware that you might experience slippage in fast-moving markets.

• placeLimitOrder: This method places a limit order, which only executes at the specified price or better. It’s useful for getting a specific price, but the order might not execute if the market doesn’t reach that price. The postOnly parameter ensures the order is always a maker, not a taker.

• placeTriggerMarketOrder: This method places a trigger market order, which is activated when the market reaches a certain price. It’s useful for setting stop-loss or take-profit orders.

Note that all these methods use this.currentPriorityFee to set the transaction priority. This ensures our orders are processed quickly, even in congested network conditions.

Adding Position Management

Let’s add methods to open positions with take-profit and stop-loss orders, and to monitor our positions:

async openPositionWithTPSL(marketIndex, direction, size, entryPrice, tpPercentage = 0.05, slPercentage = 0.03) {
  console.log(`Opening ${direction} position for market ${marketIndex}`);

  await this.placeMarketOrder(marketIndex, direction, size);

  const tpPrice = direction === "long" ? entryPrice * (1 + tpPercentage) : entryPrice * (1 - tpPercentage);
  const slPrice = direction === "long" ? entryPrice * (1 - slPercentage) : entryPrice * (1 + slPercentage);

  await this.placeLimitOrder(
    marketIndex,
    direction === "long" ? "short" : "long",
    size,
    tpPrice
  );

  await this.placeTriggerMarketOrder(
    marketIndex,
    direction === "long" ? "short" : "long",
    size,
    slPrice,
    direction === "long" ? "below" : "above"
  );

  console.log(`Position opened with TP at ${tpPrice} and SL at ${slPrice}`);
}

async monitorPosition(marketIndex) {
  console.log(`Monitoring position for market ${marketIndex}`);

  try {
    const position = await this.user.getPerpPosition(marketIndex);

    if (position && !position.baseAssetAmount.eq(new BN(0))) {
      const size = position.baseAssetAmount.toNumber() / BASE_PRECISION;
      const direction = position.baseAssetAmount.gt(new BN(0)) ? "long" : "short";
      const entryPrice = Math.abs(position.quoteEntryAmount.toNumber() / position.baseAssetAmount.toNumber()) / (PRICE_PRECISION / QUOTE_PRECISION);

      console.log(`Open ${direction} position: Size: ${size}, Entry Price: $${entryPrice}`);

      const unrealizedPnl = await this.user.getUnrealizedPNL();
      console.log(`Unrealized PNL: $${unrealizedPnl.toNumber() / QUOTE_PRECISION}`);

    } else {
      console.log(`No open position for market ${marketIndex}`);
    }
  } catch (error) {
    console.error(`Error monitoring position: ${error.message}`);
  }
}

The openPositionWithTPSL method opens a position with a market order and immediately places take-profit (TP) and stop-loss (SL) orders. This is a common risk management strategy in trading.

The monitorPosition method checks the current state of our position, including its size, direction, entry price, and unrealized profit or loss. This is crucial for tracking the performance of our trades.

7. Running and Testing Your Bot

Now that we have our basic bot functionality, let’s create a method to run our bot:

async function runBot() {
  const bot = new TradingBot();
  await bot.initialize();

  // Initial priority fee update
  await bot.updatePriorityFee();

  // Update priority fee every 2 minutes
  setInterval(() => bot.updatePriorityFee(), bot.priorityFeeUpdateInterval);

  // Example: Open a long position on market 0 (assuming it's SOL-PERP) with size 1 and entry price $20
  await bot.openPositionWithTPSL(0, "long", 1, 20);

  // Monitor the position every minute
  setInterval(() => bot.monitorPosition(0), 60000);
}

runBot().catch(console.error);

To run your bot, make sure you have a .env file in your project directory with the following content:

RPC_ENDPOINT=your_solana_rpc_endpoint
PRIVATE_KEY=your_wallet_private_key
DRIFT_PROGRAM_ID=drift_program_id
HELIUS_API_KEY=your_helius_api_key

Then, you can run your bot using:

node bot.js

8. Conclusion and Next Steps

Congratulations! You’ve built a high-performance trading bot for the Drift protocol with dynamic priority fees. This bot is capable of placing various types of orders, managing positions with take-profit and stop-loss orders, and adjusting its transaction priority based on network conditions.

Remember, this is just the beginning. Continue to learn about trading strategies, risk management, and the Drift protocol to enhance your bot further. Here are some next steps to consider:

1. Refine Your Trading Strategy: The current bot opens positions based on hardcoded parameters. Develop and implement more sophisticated trading strategies based on technical analysis, fundamental analysis, or machine learning models.

2. Implement Risk Management: Add features like dynamic position sizing, adjustable take-profit and stop-loss levels, and overall account risk management.

3. Enhance Error Handling: Implement more robust error handling and retry mechanisms. Consider scenarios like network errors, insufficient funds, or unexpected market conditions.

4. Add Logging and Monitoring: Implement a comprehensive logging system to track all bot actions, trades, and errors. Consider using a monitoring service to alert you of any issues in real-time.

5. Backtesting and Paper Trading: Before risking real capital, implement a backtesting system to evaluate your strategies on historical data. Then, use paper trading (simulated trading with real market data but fake money) to test your bot in real market conditions without financial risk.

6. Optimize Performance: Look for ways to optimize your bot’s performance. This could include more efficient API usage, better management of Solana RPCs, or implementing websockets for real-time data updates.

7. Expand to Multiple Markets: Modify your bot to trade on multiple Drift markets simultaneously, potentially implementing portfolio management and diversification strategies.

8. Implement a User Interface: Consider building a simple web interface to monitor your bot’s performance and adjust parameters without needing to modify the code directly.

9. Stay Updated: Keep your bot updated with the latest versions of the Drift SDK and other dependencies. Stay informed about changes to the Drift protocol that might affect your bot’s operation.

10. Continuous Learning: The crypto and DeFi spaces evolve rapidly. Continually educate yourself about new developments in trading strategies, blockchain technology, and the Drift ecosystem.

Remember, while automated trading can be exciting and potentially profitable, it also comes with significant risks. Always adhere to these important guidelines:

• Start Small: Begin with small trade sizes while you’re testing and refining your bot.
• Use Test Networks: Utilize Solana’s testnet or devnet for initial testing before moving to mainnet.
• Monitor Regularly: Even automated bots require human oversight. Regularly check on your bot’s performance and be prepared to intervene if necessary.
• Understand the Risks: Algorithmic trading can amplify both gains and losses. Never risk more capital than you can afford to lose.
• Stay Compliant: Be aware of and comply with all relevant regulations in your jurisdiction regarding algorithmic trading and cryptocurrency.

Lastly, remember that this tutorial provides a starting point. Real-world trading bots often require much more complexity, rigorous testing, and ongoing maintenance. As you continue to develop and refine your bot, you’ll gain valuable experience and insights into both trading and software development.

Happy coding, and may your trades be profitable!

Additional Resources

To further your learning and stay updated with the latest developments, consider exploring these resources:

1. Drift Protocol Documentation: The official documentation for the Drift protocol.
2. Drift Protocol GitHub: The source code for the Drift protocol.
3. Solana Cookbook: A developer resource for building on Solana.
4. Crypto Trading Bot Guide: An Investopedia guide on crypto trading bots.
5. Algorithmic Trading Strategies: An overview of common algorithmic trading strategies.

Remember to always DYOR (Do Your Own Research) and continually educate yourself in this rapidly evolving field. Good luck with your trading bot development journey!