Add Precision and API support for gridbot

Author: valamidev

package.json

@@ -46,7 +46,7 @@
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
     "rxjs": "^6.5.4",
-    "sand-ex": "^0.1.1",
+    "sand-ex": "^0.1.3",
     "synaptic": "^1.1.4",
     "talib": "^1.1.3",
     "tulind": "^0.8.18",

src/__test__/gridbot/gridbot.spec.ts

@@ -82,7 +82,14 @@ describe('#Gridbot', () => {
   });
 
   it('should Constructor set the properties', async () => {
-    expect(gridBot.quotePerGrid).toBe(gridBotConfig.balanceQuote / gridBotConfig.gridQuantity);
+
+    let sumGridQuote = 0;
+
+    gridBot.grids.forEach(e => {
+      sumGridQuote += e.maxQuantity * e.priceLow;
+    });
+
+    expect(sumGridQuote).toBeLessThanOrEqual(gridBotConfig.balanceQuote);
     expect(gridBot.grids).toHaveLength(gridBotConfig.gridQuantity);
   });
 
@@ -128,10 +135,10 @@ describe('#Perfect Gridbot', () => {
       expect(grid.activeOrderId).toBeGreaterThan(1);
     });
 
-    expect(ExchangeBalance).toMatchObject({ balanceQuote: 1049.874949438876 });
+    expect(ExchangeBalance).toMatchObject({ balanceQuote: 1047.28074283 });
     expect(gridBot).toMatchObject({
       balanceAsset: 0,
-      balanceQuote: 1049.874949438876,
+      balanceQuote: 1047.2807428449998,
     });
   });
 
@@ -158,9 +165,9 @@ describe('#Perfect Gridbot', () => {
     });
 
 
-    expect(ExchangeBalance).toMatchObject({ balanceAsset: 0.1028258926975 });
+    expect(ExchangeBalance).toMatchObject({ balanceAsset: 0.09748776 });
     expect(gridBot).toMatchObject({
-      balanceAsset: 0.1028258926975,
+      balanceAsset: 0.09748776,
     });
   });
 
@@ -187,7 +194,7 @@ describe('#Perfect Gridbot', () => {
     });
 
 
-    expect(ExchangeBalance).toMatchObject({ balanceAsset: 0, balanceQuote: 1099.749898877752 });
+    expect(ExchangeBalance).toMatchObject({ balanceAsset: 0, balanceQuote: 1094.56148566 });
 
   });
 

src/grid_bot/index.ts

@@ -20,6 +20,7 @@ export type GridBotConfig = {
   gridQuantity: number;
   balanceQuote: number;
   fee: number;
+  precision?: number;
 };
 
 type Grid = {
@@ -33,37 +34,49 @@ type Grid = {
 export class GridBot {
   balanceQuote: number;
   balanceAsset: number;
-  quotePerGrid: number;
+  assetPerGrid: number;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   orderHistory: any[];
   grids: Grid[];
   exchange: SandExchange;
   syncedOrders: Set<number>;
   private readonly fee: number;
+  private readonly precision: number;
 
   constructor(config: GridBotConfig) {
     this.orderHistory = [];
     this.syncedOrders = new Set();
     this.balanceQuote = config.balanceQuote;
     this.balanceAsset = 0;
     this.fee = config.fee;
+    this.precision = config.precision || DEFAULT_PRECISION;
 
     this.exchange = new SandExchange({
       balanceAsset: this.balanceAsset,
       balanceQuote: this.balanceQuote,
       fee: this.fee,
+      precision: this.precision,
     });
 
-    // Get last money partition ignore round-robin parts
-    this.quotePerGrid = this.balanceQuote / config.gridQuantity;
+    const pricePerStep = (config.priceHigh - config.priceLow) / config.gridQuantity;
+    const totalPriceStep = (config.gridQuantity ** 2 + config.gridQuantity) / 2; // n * n + n / 2
+
+    this.assetPerGrid = this.balanceQuote / (config.gridQuantity * config.priceLow + totalPriceStep * pricePerStep);
+    this.assetPerGrid = floor(this.assetPerGrid, DEFAULT_PRECISION);
 
     this.grids = [...Array(config.gridQuantity)].map((_, i) => {
       const priceLow = config.priceLow + ((config.priceHigh - config.priceLow) / config.gridQuantity) * i;
       const priceHigh = config.priceLow + ((config.priceHigh - config.priceLow) / config.gridQuantity) * (i + 1);
-      const maxQuantity = floor(this.quotePerGrid / priceLow, DEFAULT_PRECISION);
+
       const ownedQuantity = 0;
 
-      return { priceLow, priceHigh, maxQuantity, ownedQuantity, activeOrderId: null };
+      return {
+        priceLow,
+        priceHigh,
+        maxQuantity: this.assetPerGrid,
+        ownedQuantity,
+        activeOrderId: null,
+      };
     });
   }
 
@@ -82,7 +95,7 @@ export class GridBot {
         const grindIndex = this.grids.findIndex(grid => grid.activeOrderId === order.orderId);
 
         if (order.side === OrderSide.BUY) {
-          const bookedQuantity = order.executedQty * (1 - this.fee);
+          const bookedQuantity = floor(order.executedQty * (1 - this.fee), this.precision);
           this.balanceAsset += bookedQuantity;
           this.balanceQuote -= order.executedQty * order.price;
 
@@ -102,6 +115,7 @@ export class GridBot {
           };
         }
 
+        this.orderHistory.push(order);
         this.syncedOrders.add(order.orderId);
       }
     });

src/httpserver/controllers/backtest.controller.ts

@@ -5,7 +5,7 @@ import { OptimizeConfig, BacktestService } from '../services/backtest.service';
 
 @Controller('backtest')
 export class BacktestController {
-  constructor(private backtestService: BacktestService) { }
+  constructor(private backtestService: BacktestService) {}
 
   @Post('optimize')
   async optimize(@Body() optimizeConfig: OptimizeConfig): Promise<any> {
@@ -17,16 +17,4 @@ export class BacktestController {
       throw new InternalServerErrorException();
     }
   }
-
-  @Post('gridbot')
-  async gridbot(@Body() optimizeConfig: OptimizeConfig): Promise<any> {
-    try {
-      return await this.backtestService.optimize(optimizeConfig);
-    } catch (err) {
-      logger.error(`NestJS API error, ${err}`);
-
-      throw new InternalServerErrorException();
-    }
-  }
-
 }

src/httpserver/controllers/gridbot.controller.ts

@@ -1,14 +1,14 @@
 import { Controller, Post, InternalServerErrorException, Body } from '@nestjs/common';
 
 import { logger } from '../../logger';
-import { GridbotService } from '../services/gridbot.service';
+import { GridbotService, GridbotConfig } from '../services/gridbot.service';
 
 @Controller('gridbot')
 export class GridbotController {
-  constructor(private gridbotService: GridbotService) { }
+  constructor(private gridbotService: GridbotService) {}
 
   @Post('backtest')
-  async backtest(@Body() gridbotConfig: any): Promise<any> {
+  async backtest(@Body() gridbotConfig: GridbotConfig): Promise<any> {
     try {
       return await this.gridbotService.backtest(gridbotConfig);
     } catch (err) {

src/httpserver/services/gridbot.service.ts

@@ -1,16 +1,31 @@
 import { Injectable } from '@nestjs/common';
 import { OHLCV } from 'sand-ex/build/types';
-import _ from 'lodash';
+// import _ from 'lodash';
 
 import tradePairs from '../../tradepairs/tradepairs';
 import { GridBotConfig, GridBot } from '../../grid_bot';
 
+export interface GridbotConfig {
+  exchange: string;
+  symbol: string;
+  priceLow: number;
+  priceHigh: number;
+  gridQuantity: number;
+  fee: number;
+  rangeInDays: number;
+}
+
 @Injectable()
 export class GridbotService {
-  async backtest(config: any): Promise<any> {
-    const exchange = 'binance';
-    const symbol = 'BTC/USDT';
-    const candleLimit = 1440 * 30;
+  async backtest(gridbotConfig: GridbotConfig): Promise<any> {
+    const exchange = gridbotConfig.exchange ?? 'binance';
+    const symbol = gridbotConfig.symbol ?? 'BTC/USDT';
+    const { rangeInDays, priceLow, priceHigh, gridQuantity } = gridbotConfig;
+    const fee = gridbotConfig.fee ?? 0.00075; // 0.0075% / 100,
+
+    const candleLimit = 1440 * rangeInDays;
+
+    const testQuote = 100000;
 
     const candleData = await tradePairs.getCandlestickFromDB(exchange, symbol, 60, candleLimit);
 
@@ -19,27 +34,32 @@ export class GridbotService {
 
       // Strategy optimizer, helper function
       const gridBotConfig: GridBotConfig = {
-        priceLow: 7500,
-        priceHigh: 10000,
-        gridQuantity: 8,
-        balanceQuote: 10000,
-        fee: 0.00075, // 0.0075% / 100,
+        priceLow,
+        priceHigh,
+        gridQuantity,
+        balanceQuote: testQuote,
+        fee,
       };
 
       const gridBot = new GridBot(gridBotConfig);
 
-      console.log(candleSticks.length);
+      const profits = [];
 
       for (let i = 0; i < candleSticks.length; i++) {
         gridBot.update((candleSticks[i] as unknown) as OHLCV);
-      }
 
-      console.log(gridBot.exchange.getOrders().length);
+        profits.push(gridBot.balanceQuote + gridBot.balanceAsset * candleSticks[candleSticks.length - 1][4]);
+      }
 
-      console.log(gridBot.balanceAsset);
-      console.log(gridBot.balanceQuote + gridBot.balanceAsset * candleSticks[candleSticks.length - 1][4]);
+      const totalEndBalance = gridBot.balanceQuote + gridBot.balanceAsset * candleSticks[candleSticks.length - 1][4];
 
-      return '';
+      return {
+        balanceAsset: gridBot.balanceAsset,
+        balanceQuote: gridBot.balanceQuote,
+        totalEndBalance,
+        profitPct: (totalEndBalance / 100000 - 1) * 100,
+        orderHistory: gridBot.orderHistory,
+      };
     }
   }
 }