adding buy and sell logic

dennohpeter · dennohpeter · commit 2d4d332ef7b0 · 2021-10-17T14:37:17.000+03:00
added support for other blockchains such as bsc, optimism, arbitrum
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,20 +12,20 @@
 `v1.0.0`
 
 - Bug fix and optimizations
-- Add support for binance smart chain(BSC)
+- Add support for binance smart chain(BSC) :heavy_check_mark:
 - Testing on mainnet
 
 `v1.0.2`
 
-- Add support for Optimism Blockchain
+- Add support for Optimism Blockchain :heavy_check_mark:
 
 `v1.0.3`
 
-- Add support for Arbitrum Blockchain
+- Add support for Arbitrum Blockchain :heavy_check_mark:
 
 `v1.0.4`
 
-- Add support for Polygon Matic Blockchain
+- Add support for Polygon Matic Blockchain :heavy_check_mark:
 
 `v1.0.5`
 
diff --git a/config.ts b/config.ts
@@ -1,18 +1,24 @@
-if (!process.env.PUBLIC_KEY && !process.env.PRIVATE_KEY && !process.env.ETH_IN_AMOUNT && !process.env.DB_URL) {
+if (!process.env.INFURA_API_KEY && !process.env.PUBLIC_KEY && !process.env.PRIVATE_KEY && !process.env.ETH_IN_AMOUNT && !process.env.DB_URL) {
 
-    throw new Error("PUBLIC_KEY && PRIVATE_KEY && ETH_IN_AMOUNT && DB_URL, Must be defined in your .env file");
+    throw new Error("INFURA_API_KEY && PUBLIC_KEY && PRIVATE_KEY && ETH_IN_AMOUNT && DB_URL, Must be defined in your .env file");
 }
 export const config = {
     WALLET: {
         PUBLIC_KEY: process.env.PUBLIC_KEY!,
         PRIVATE_KEY: process.env.PRIVATE_KEY!
     },
     PROVIDERS: {
-        INFURA_API_KEY: ''
+        INFURA_API_KEY: process.env.INFURA_API_KEY!
     },
     NETWORK: {
-        ID: 1 // 1 eth, 56 is bsc, 137 polygon, 10 optimism, 42161 arbitrum
+        ID: process.env.NETWORK_ID || 1 // 1 eth, 56 is bsc, 137 polygon, 10 optimism, 42161 arbitrum
     },
+    PROFIT_THRESHOLD: {   // profit % you atleast want
+        BUY: 0.2,
+        SELL: 2
+    },
+    SLIPPAGE: 0.5,
+    EXPLORER: '',
     PRICE_CHECK_INTERVAL_IN_SECONDS: process.env.PRICE_CHECK_INTERVAL_IN_SECONDS || 45,
     ETH_IN_AMOUNT: parseFloat(process.env.ETH_IN_AMOUNT!),
     DB_URL: process.env.DB_URL!
diff --git a/src/index.ts b/src/index.ts
@@ -2,11 +2,11 @@ import chalk from "chalk";
 import { connect } from "mongoose";
 import { schedule } from "node-cron";
 import { config } from "../config";
-import { OneInch } from "./lib/1inch.io";
-import { Quote, Token } from "./types/1inch";
+import { OneInch } from "./lib";
+import { Quote, Direction } from "./types";
 const chalkTable = require('chalk-table');
 import BigNumber from "bignumber.js";
-import { flat } from "./utils";
+import { buildTradeMsg, flat } from "./utils";
 import { MONITORED_TOKENS } from "./data/token";
 
 const Main = async () => {
@@ -37,7 +37,6 @@ const Main = async () => {
     const options = {
         useNewUrlParser: true,
         useUnifiedTopology: true,
-        useCreateIndex: true,
         keepAlive: true,
         connectTimeoutMS: 60000,
         socketTimeoutMS: 60000,
@@ -47,7 +46,7 @@ const Main = async () => {
         console.log("Connected to MongoDb :)");
     }).catch(async (err) => {
         let error = JSON.parse(JSON.stringify(err))
-        console.log('Mongo Error:', error?.name);
+        console.log('Mongo Error:', error);
     });
     console.log(`---`.repeat(10));
 
@@ -60,6 +59,9 @@ const Main = async () => {
     console.log(`---`.repeat(10));
 
     let ethInAmount = new BigNumber(config.ETH_IN_AMOUNT).shiftedBy(18).toString()
+    let on_cooldown = false
+    let message = ''
+
     schedule(`*/${config.PRICE_CHECK_INTERVAL_IN_SECONDS} * * * * *`, async function () {
         console.log(`***`.repeat(10));
         MONITORED_TOKENS.forEach(async (token: any) => {
@@ -110,8 +112,140 @@ const Main = async () => {
                 ]);
                 if (JSON.stringify(best_buy_protocols) != JSON.stringify(best_sell_protocols)) {
                     console.log(table);
+
+
+                    if (profit_pct >= config.PROFIT_THRESHOLD.BUY && !on_cooldown) {
+                        let nonce: number = await oneInch.getNonce()
+                        console.log(`Nonce:`, nonce);
+
+                        on_cooldown = true
+                        /**
+                         * Start of Buy => Approve? => Sell Txs
+                         */
+                        try {
+
+                            console.log(`Initiating a buy for token ${token.ticker} ...`);
+                            // build  buy Tx
+                            let txData = await oneInch.buildTx({
+                                srcToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+                                toToken: token.address,
+                                srcAmount: ethInAmount,
+                                slippage: config.SLIPPAGE
+                            })
+                            console.log(`Buy Tx Data:`, txData);
+
+                            // send a buy Tx
+                            nonce++;
+                            oneInch.sendTx({
+                                data: txData.tx,
+                                nonce
+                            }).then(async (tx: any) => {
+                                if (tx.hash) {
+
+                                    // build Buy Tg Msg
+                                    message = await buildTradeMsg({ data: tx, profit_pct: profit_pct, side: Direction.BUY })
+                                    // send Msg to Tg
+                                    sendMessage(users, message);
+
+                                    try {
+                                        /**
+                                         *  Approve Token if it has not been approved before and save it to db
+                                         */
+                                        // approve if token has not been approved
+                                        const token_is_approved = await Approve.exists({ token: token, by: process.env.PUBLIC_KEY!.toLowerCase() })
+                                        if (!token_is_approved) {
+                                            // approve if not approved
+                                            message = `Approving ${token.description}...`
+                                            sendMessage(users, message)
+                                            let txData = await oneInch.approve(token.address)
+                                            nonce++;
+                                            await oneInch.sendTx({
+                                                data: txData.tx,
+                                                nonce
+                                            }).then((tx: any) => {
+                                                console.log(`${token.ticker} has been approved successfully.`)
+                                                sendMessage(users, message)
+                                            }).catch((err) => {
+                                                console.log(`Error: `, err)
+                                            });
+                                        }
+
+
+                                        /**
+                                         * Get the balance of  the bought token shpuld be atleast be 1/2 of what was expected
+                                         */
+
+                                        let tries = 0
+                                        let tokenBalance = '0'
+                                        while (tries < 2000) {
+                                            tokenBalance = await oneInch.balanceOf(tx.toToken.address)
+                                            if (parseInt(tokenBalance) > parseInt(new BigNumber(token_amount).multipliedBy(0.5).toString())) {
+                                                break
+                                            }
+                                            tries++
+                                        }
+                                        /**
+                                         * End of Balance Check
+                                         */
+
+                                        /**
+                                         * Sell the bought tokens/assets to the exchange with the best rates
+                                         */
+                                        message = `Initiating a sell for token ${token.ticker}...`
+                                        // build  Sell Tx
+                                        let txData = await oneInch.buildTx({
+                                            srcToken: token.address,
+                                            toToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+                                            srcAmount: tokenBalance,
+                                            slippage: config.SLIPPAGE
+                                        })
+                                        console.log(`Sell Tx Data:`, txData);
+
+                                        // send the sell Tx
+                                        nonce++;
+                                        oneInch.sendTx({
+                                            data: txData.tx,
+                                            nonce
+                                        }).then(async (tx: any) => {
+                                            if (tx.hash) {
+
+                                                // build Sell Tg Msg
+                                                message = await buildTradeMsg({ data: tx, profit_pct: profit_pct, side: Direction.SELL })
+                                                // send Msg to Tg
+                                                sendMessage(users, message);
+
+
+                                            }
+                                        }).catch((err) => {
+                                            console.log(`Error:`, err)
+                                        })
+
+                                        /**
+                                         * End of Sell Tx
+                                         */
+
+                                    }
+                                    catch (error) {
+                                        console.error(`Error:`, error)
+                                    }
+                                }
+                            }
+                            ).catch((err) => {
+                                console.log(`Error:`, err);
+                            });
+
+
+                        } catch (error) {
+                            console.error(`Error:`, error)
+                        }
+                        /**
+                        * End of Buy => Approve? => Sell Txs
+                        */
+
+                    }
                 }
 
+
             } catch (error: any) {
                 console.error('Error:', JSON.parse(JSON.stringify(error)).code);
             }
diff --git a/src/lib/1inch.ts b/src/lib/1inch.ts
@@ -1,6 +1,7 @@
 import axios from "axios";
 import { config } from "../../config";
 import { Quote } from "../types/1inch";
+import { toHex } from "../utils";
 import { Aggr } from "./aggr";
 
 export class OneInch extends Aggr {
@@ -42,13 +43,24 @@ export class OneInch extends Aggr {
      * @param slippage - slippage tolerance
      * @returns tx data that can be send to the network
      */
-    buildTx = async (srcToken: string, toToken: string, srcAmount: number, slippage?: number): Promise<string> => {
+    buildTx = async (params: { srcToken: string, toToken: string, srcAmount: number | string, slippage?: number, gasLimit?: string }) => {
+        const { srcToken, toToken, srcAmount, slippage, gasLimit } = params;
         try {
             let defaultSlippage = 0.5
-            const { data } = await axios({
+            console.log(defaultSlippage)
+            const { data }: any = await axios({
                 method: "GET",
-                url: `${this.API_URL}${config.NETWORK.ID}/swap?fromTokenAddress=${srcToken}&toTokenAddress=${toToken}&amount=${srcAmount}&fromAddress=${config.WALLET.PUBLIC_KEY}&disableEstimate=false&slippage=${slippage ? `${slippage}` : defaultSlippage}`
+                url: `${this.API_URL}${config.NETWORK.ID}/swap?fromTokenAddress=${srcToken}&toTokenAddress=${toToken}&amount=${srcAmount}&fromAddress=${config.WALLET.PUBLIC_KEY}&disableEstimate=true&slippage=${slippage ? `${slippage}` : defaultSlippage}`
             })
+            delete data.tx.gasPrice; //ethersjs will find the gasPrice needed   
+            delete data.tx.gas;
+
+            if (gasLimit) {
+                data.tx.gasLimit = toHex(parseInt(gasLimit))
+            }
+
+            data.tx["value"] = toHex(parseInt(data.tx["value"]))
+
             return data
         } catch (error: any) {
             throw new Error(JSON.stringify(error));
@@ -80,10 +92,14 @@ export class OneInch extends Aggr {
      */
     approve = async (tokenAddress: string, amount?: string) => {
         try {
-            const { data } = await axios({
+            const { data }: any = await axios({
                 method: "GET",
                 url: `${this.API_URL}${config.NETWORK.ID}/approve/calldata?tokenAddress=${tokenAddress}`
             })
+            delete data.tx.gasPrice; //ethersjs will find the gasPrice needed   
+            delete data.tx.gas;
+
+            data.tx["value"] = toHex(parseInt(data.tx["value"]))
             return data
         } catch (error: any) {
             throw new Error(JSON.stringify(error));
diff --git a/src/lib/aggr.ts b/src/lib/aggr.ts
@@ -13,13 +13,18 @@ export abstract class Aggr {
         this.account = new Wallet(config.WALLET.PRIVATE_KEY, this.provider);
         this.API_URL = api_url
     }
-
+    /**
+     * Sends a tx to the blockchain
+     * @param data - Tx data 
+     * @param nonce - wallet current nonce 
+     * @returns Tx hash if successful else error message
+     */
     sendTx = async (params: { data: any, nonce: number }) => {
         const { data, nonce } = params
         try {
 
             if (!isNaN(nonce)) {
-                data.nonce = nonce
+                data.nonce = nonce + 1
             }
 
             const tx = await this.account.sendTransaction(data)
@@ -47,9 +52,9 @@ export abstract class Aggr {
 
     /**
      * Gets the current nonce of a wallet
-     * @returns nonce
+     * @returns  wallet's current nonce
      */
     getNonce = async (): Promise<number> => {
-        return await this.provider.getTransactionCount(config.WALLET.PUBLIC_KEY)
+        return await this.account.getTransactionCount()
     }
 }
diff --git a/src/lib/index.ts b/src/lib/index.ts
@@ -0,0 +1 @@
+export * from './1inch'
diff --git a/src/types/enums.ts b/src/types/enums.ts
@@ -0,0 +1,4 @@
+export enum Direction {
+    SELL = 'SELL',
+    BUY = 'BUY'
+}
diff --git a/src/types/index.ts b/src/types/index.ts
@@ -0,0 +1,2 @@
+export * from './1inch';
+export * from './enums';
diff --git a/src/utils/common.ts b/src/utils/common.ts
@@ -1,7 +1,42 @@
+import BigNumber from "bignumber.js"
+import { config } from "../../config"
+import { Direction } from "../types"
+
 export const flat = async (arr: Array<any>, start: number = 0, end: number = 3): Promise<Array<any>> => {
     if (start < end) {
         start += 1
         return flat([].concat(...arr), start)
     }
     return arr
+}
+
+export const toHex = (value: number) => {
+    return `0x${value.toString(16)}`
+}
+export const humanizeBalance = async (balance: string | number, decimals: number) => {
+    return new BigNumber(balance).shiftedBy(-decimals).toString()
+}
+
+export const buildTradeMsg = async (params: { data: any, profit_pct: number, side: Direction }): Promise<string> => {
+    const { data, profit_pct, side } = params
+
+    let dexes = (await flat(data.protocols)).map((quote: any) => quote.name).join(', ')
+    let msg = `* NEW TRADE NOTIFICATION *\n-- - `
+    msg += `\n*Direction:* ${side}`
+    if (side == Direction.SELL) {
+
+        msg += `\n*Token Amount:* ${await humanizeBalance(data.fromTokenAmount, data.fromToken.decimals)}`
+        msg += `\n*Token:* ${data.fromToken.name}`
+        msg += `\n*ETH Amount:* ${await humanizeBalance(data.toTokenAmount, data.toToken.decimals)}`
+    } else {
+        msg += `\n*ETH Amount:* ${await humanizeBalance(data.fromTokenAmount, data.fromToken.decimals)}`
+        msg += `\n*Token Amount:* ${await humanizeBalance(data.toTokenAmount, data.toToken.decimals}`
+        msg += `\n*Token:* ${data.fromToken.name}`
+    }
+    msg += `\n*Profit PCT:* ${profit_pct.toFixed(6)}%`
+    msg += `\n*Dex:* ${dexes}`
+    msg += `\n*Gas Limit:* ${data.gasLimit}`
+    msg += `\n*Hash:* [${data.hash.toUpperCase()}](${config.EXPLORER}${data.hash})`
+
+    return msg
 }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+export * from './1inch';`
	`2`	`+export * from './enums';`