🚀 initial commit

Author: dennohpeter

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.env

config.ts

@@ -0,0 +1,20 @@
+if (!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");
+}
+export const config = {
+    WALLET: {
+        PUBLIC_KEY: process.env.PUBLIC_KEY!,
+        PRIVATE_KEY: process.env.PRIVATE_KEY!
+    },
+    PROVIDERS: {
+        INFURA_API_KEY: ''
+    },
+    NETWORK: {
+        ID: 1 // 1 eth, 56 is bsc, 137 polygon, 10 optimism, 42161 arbitrum
+    },
+    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!
+
+}

example.env

@@ -0,0 +1,11 @@
+# Wallet
+PRIVATE_KEY = ''
+PUBLIC_KEY = ''
+
+PRICE_CHECK_INTERVAL_IN_SECONDS=45
+
+# Trading Preference
+ETH_IN_AMOUNT = '1'
+
+# Database
+DB_URL = ''

package.json

@@ -0,0 +1,32 @@
+{
+  "name": "multidexarbbot",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "ts-node-dev -r dotenv/config src/index.ts"
+  },
+  "author": {
+    "name": "Dennoh Peter",
+    "email": "[email protected]"
+  },
+  "keywords": [
+    "Arbitrage",
+    "MultiDex",
+    "Trading"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@types/node-cron": "^3.0.0",
+    "axios": "^0.22.0",
+    "bignumber.js": "^9.0.1",
+    "chalk": "^4.1.2",
+    "chalk-table": "^1.0.2",
+    "dotenv": "^10.0.0",
+    "ethers": "^5.4.7",
+    "mongoose": "^6.0.9",
+    "node-cron": "^3.0.0",
+    "telegraf": "^4.4.2"
+  }
+}

src/data/token.ts

@@ -0,0 +1,36 @@
+export const MONITORED_TOKENS = [
+
+    // { address: "0xdac17f958d2ee523a2206206994597c13d831ec7", symbol: "USDT", name: "USD Tether" },
+    { address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", symbol: "USDC", name: "USD Coin" },
+    // { address: "0x6b175474e89094c44da98b954eedeac495271d0f", symbol: "DAI", name: "MakerDao StableCoin" },
+    // //     { address: "0x3845badade8e6dff049820680d1f14bd3903a5d0", symbol: "SAND", name: "Sandbox" },
+    // { address: "0xd46ba6d942050d489dbd938a2c909a5d5039a161", symbol: "AMPL", name: "Ampleforth" },
+    // //     { address: "0x956f47f50a910163d8bf957cf5846d573e7f87ca", symbol: "FEI", name: "Fei Protocol StableCoin" },
+    // { address: "0xbc396689893d065f41bc2c6ecbee5e0085233447", symbol: "PERP", name: "Defi Trading Platform with AMMs" },
+    // //     { address: "0x1453dbb8a29551ade11d89825ca812e05317eaeb", symbol: "TEND", name: "Tendies" },
+    // // { address: "0x2b591e99afe9f32eaa6214f7b7629768c40eeb39", symbol: "HEX", name: "Staking" },
+    //     { address: "0xe53ec727dbdeb9e2d5456c3be40cff031ab40a55", symbol: "SUPER", name: "SuperFarm" },
+    //     { address: "0xa47c8bf37f92abed4a126bda807a7b7498661acd", symbol: "UST", name: "Mirror StableCoin" },
+    // //     { address: "0x853d955acef822db058eb8505911ed77f175b99e", symbol: "FRAX", name: "Frax" },
+    // { address: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599", symbol: "WBTC", name: "Wrapped Bitcoin" },
+    // //     { address: "0x72e364f2abdc788b7e918bc238b21f109cd634d7", symbol: "MVI", name: "Metaverse Virtual Reality" },
+    // //     { address: "0x95ad61b0a150d79219dcf64e1e6cc01f0b64c4ce", symbol: "SHIB", name: "Shiba Inu" },
+    // { address: "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984", symbol: "UNI", name: "Uniswap" },
+    // // { address: "0x1c9922314ed1415c95b9fd453c3818fd41867d0b", symbol: "TOWER", name: "Crazy Defense Heroes" },
+    // // { address: "0x990f341946a3fdb507ae7e52d17851b87168017c", symbol: "STRONG", name: "StrongBlock Eth MasterNodes as a service" },
+    // //     { address: "0x07150e919b4de5fd6a63de1f9384828396f25fdc", symbol: "BASE", name: "Base Protocol" },
+    // //     { address: "0xc770eefad204b5180df6a14ee197d99d808ee52d", symbol: "FOX", name: "Fox" },
+    // //     { address: "0xfb7b4564402e5500db5bb6d63ae671302777c75a", symbol: "DEXT", name: "Dex Tools " },
+    // //     { address: "0x514910771af9ca656af840dff83e8264ecf986ca", symbol: "LINK", name: "Chainlink Oracle" },
+    // { address: "0x557b933a7c2c45672b610f8954a3deb39a51a8ca", symbol: "REVV", name: "REv Motorsport" },
+    //     { address: "0x09a3ecafa817268f77be1283176b946c4ff2e608", symbol: "MIR", name: "Mirror Protocol" },
+    { address: "0x8e870d67f660d95d5be530380d0ec0bd388289e1", symbol: "PAX", name: "Paxos Standard" },
+    { address: "0x111111111117dc0aa78b770fa6a738034120c302", symbol: "1INCH", name: "1Inch Token" },
+    { address: "0x0f5d2fb29fb7d3cfee444a200298f468908cc942", symbol: "MANA", name: "Decentralland" },
+    { address: "0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0", symbol: "MATIC", name: "Polygon Network" },
+    { address: "0xde30da39c46104798bb5aa3fe8b9e0e1f348163f", symbol: "GTC", name: "GitCoin" },
+    { address: "0xa0246c9032bc3a600820415ae600c6388619a14d", symbol: "FARM", name: "Harvest Finance Staking" },
+    { address: "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f", symbol: "SNX", name: "Synthetix" },
+    { address: "0xd2877702675e6ceb975b4a1dff9fb7baf4c91ea9", symbol: "LUNA", name: "Mirror synthetics protocol token" },
+    { address: "0x35a532d376ffd9a705d0bb319532837337a398e7", symbol: "WDOGE", name: "Wrapped DogeCoin" },
+]

src/index.ts

@@ -0,0 +1,124 @@
+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";
+const chalkTable = require('chalk-table');
+import BigNumber from "bignumber.js";
+import { flat } from "./utils";
+import { MONITORED_TOKENS } from "./data/token";
+
+const Main = async () => {
+    const oneInch = new OneInch()
+    console.log('Starting...');
+    console.log(`---`.repeat(10));
+
+    // try {
+    //     bot.stop()
+    // }
+    // catch (err) {
+    // }
+
+    // console.log('Connecting to telegram bot...\n---');
+    // await bot.launch().then((result) => {
+    //     console.log('Connected to telegram bot!');
+
+    // }).catch(async (err) => {
+    //     let error = JSON.parse(JSON.stringify(err))
+    //     console.log('Telegram Error:', error?.message);
+
+    // }).catch((error: any) => {
+    //     console.log('Telegram error:', error);
+    // })
+
+    // console.log(`---`.repeat(10));
+    console.log('Connecting to MongoDb...\n---');
+    const options = {
+        useNewUrlParser: true,
+        useUnifiedTopology: true,
+        useCreateIndex: true,
+        keepAlive: true,
+        connectTimeoutMS: 60000,
+        socketTimeoutMS: 60000,
+    }
+
+    await connect(config.DB_URL, options).then((result) => {
+        console.log("Connected to MongoDb :)");
+    }).catch(async (err) => {
+        let error = JSON.parse(JSON.stringify(err))
+        console.log('Mongo Error:', error?.name);
+    });
+    console.log(`---`.repeat(10));
+
+    await oneInch.getProtocols()
+        .then((protocols: string[]) => {
+            console.log(`Finding the best route for trade on the following exchanges ${protocols.join(', ')}...`);
+        })
+        .catch((err: any) => { })
+
+    console.log(`---`.repeat(10));
+
+    let ethAmount = new BigNumber(config.ETH_IN_AMOUNT).shiftedBy(18).toString()
+    schedule(`*/${config.PRICE_CHECK_INTERVAL_IN_SECONDS} * * * * *`, async function () {
+        console.log(`***`.repeat(10));
+        MONITORED_TOKENS.forEach(async (token: any) => {
+            try {
+                const buy_quote: Quote = await oneInch.getQuote({
+                    srcToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+                    toToken: token.address,
+                    srcAmount: ethAmount
+                })
+                let token_amount = buy_quote.toAmount
+                const sell_quote: Quote = await oneInch.getQuote({
+                    srcToken: token.address,
+                    toToken: buy_quote.srcToken.address,
+                    srcAmount: token_amount
+                })
+
+                const options = {
+                    leftPad: 0,
+                    columns: [
+                        { field: "eth_in", name: chalk.cyan("ETH IN") },
+                        { field: "buy_on_dex", name: chalk.green(`BEST BUY ROUTEs`) },
+                        { field: "sell_on_dex", name: chalk.yellow("BEST SELL ROUTEs") },
+                        { field: "token_amount", name: chalk.yellow("Token OUT") },
+                        { field: "eth_out", name: chalk.yellow("ETH OUT") },
+                        { field: "profit", name: chalk.yellow("PROFIT PCT") },
+                        { field: "time", name: chalk.magenta("Time 📅") },
+                        { field: "rate", name: chalk.blue("Fetch Rate 🕠") },
+                    ]
+                };
+                const timestamp = new Date()
+                let eth_out = parseFloat(new BigNumber(sell_quote.toAmount).shiftedBy(-sell_quote.toToken.decimals).toFixed(6))
+                const profit_pct = ((eth_out - config.ETH_IN_AMOUNT) / config.ETH_IN_AMOUNT) * 100
+                let token_out = parseFloat(new BigNumber(token_amount).shiftedBy(-buy_quote.toToken.decimals).toFixed(6))
+                let best_buy_protocols = (await flat(buy_quote.protocols)).map((quote: any) => quote.name).join(',')
+                let best_sell_protocols = (await flat(sell_quote.protocols)).map((quote: any) => quote.name).join(',')
+                const table = chalkTable(options, [
+                    {
+                        eth_in: config.ETH_IN_AMOUNT,
+                        buy_on_dex: best_buy_protocols,
+                        sell_on_dex: best_sell_protocols,
+                        token_amount: `${token_out} ${buy_quote.toToken.symbol}`,
+                        eth_out: `${eth_out} ${sell_quote.toToken.symbol}`,
+                        profit: `${profit_pct.toFixed(6)}%`,
+                        time: timestamp.toISOString().replace(/T/, ' ').replace(/\..+/, ''),
+                        rate: `${config.PRICE_CHECK_INTERVAL_IN_SECONDS}s`
+                    },
+                ]);
+                if (!(JSON.stringify(best_buy_protocols) == JSON.stringify(best_sell_protocols))) {
+                    console.log(table);
+                }
+
+            } catch (error: any) {
+                console.error('Error:', JSON.parse(JSON.stringify(error)).code);
+            }
+
+        });
+    })
+
+}
+
+
+Main()

src/lib/1inch.io.ts

@@ -0,0 +1,54 @@
+import axios from "axios";
+import { config } from "../../config";
+import { Quote } from "../types/1inch";
+import { Aggr } from "./aggr";
+
+export class OneInch extends Aggr {
+    constructor() {
+        super(`1Inch`, `https://api.1inch.exchange/v3.0/`);
+    }
+    getQuote = async (params: { srcToken: string, toToken: string, srcAmount: number | string, side?: string }): Promise<Quote> => {
+        const { srcToken, toToken, srcAmount, side } = params
+        try {
+            const { data }: any = await axios({
+                method: 'GET',
+                url: `${this.API_URL}${config.NETWORK.ID}/quote?fromTokenAddress=${srcToken}&toTokenAddress=${toToken}&amount=${srcAmount}`
+            })
+            return {
+                srcToken: data.fromToken,
+                srcAmount: data.fromTokenAmount,
+                toToken: data.toToken,
+                toAmount: data.toTokenAmount,
+                protocols: data.protocols
+            }
+        } catch (error: any) {
+            throw new Error(JSON.stringify(error));
+
+        }
+    }
+    buildTx = async (srcToken: string, toToken: string, srcAmount: number, slippage?: number): Promise<string> => {
+        try {
+            const { data } = await axios({
+                method: "GET",
+                url: `${this.API_URL}${config.NETWORK.ID}/swap?fromTokenAddress=${srcToken}&toTokenAddress=${toToken}&amount=${srcAmount}&fromAddress=${config.WALLET.PUBLIC_KEY}&disableEstimate=true${slippage ? `&slippage=${slippage}` : ''}`
+            })
+            return data
+        } catch (error: any) {
+            throw new Error(JSON.stringify(error));
+        }
+    }
+
+    getProtocols = async (): Promise<string[]> => {
+        try {
+            const { data }: any = await axios({
+                method: "GET",
+                url: `${this.API_URL}${config.NETWORK.ID}/protocols`
+            })
+            return data.protocols
+
+        } catch (error) {
+            throw new Error(JSON.stringify(error));
+        }
+    }
+
+}

src/lib/aggr.ts

@@ -0,0 +1,55 @@
+import { ethers, Wallet } from "ethers";
+import { config } from "../../config";
+
+export abstract class Aggr {
+    readonly name: string;
+    readonly provider: ethers.providers.JsonRpcProvider;
+    readonly account: Wallet
+    readonly API_URL: string
+
+    constructor(name: string, api_url: string) {
+        this.name = name;
+        this.provider = new ethers.providers.JsonRpcProvider(config.PROVIDERS.INFURA_API_KEY)
+        this.account = new Wallet(config.WALLET.PRIVATE_KEY, this.provider);
+        this.API_URL = api_url
+    }
+
+    sendTx = async (params: { data: any, nonce: number }) => {
+        const { data, nonce } = params
+        try {
+
+            if (!isNaN(nonce)) {
+                data.nonce = nonce
+            }
+
+            const tx = await this.account.sendTransaction(data)
+            return tx
+            console.log("Tx success");
+        } catch (e) {
+            throw new Error(`Tx failure ${e}`);
+        }
+    }
+
+    /**
+     * Gets balance of a token in a wallet address
+     * @param tokenAddress token address to check to check balance
+     * @returns balance of token in a wallet
+     */
+    balanceOf = async (tokenAddress: string) => {
+        let contract = new ethers.Contract(
+            tokenAddress,
+            ['function balanceOf(address account) external view returns (uint256)'],
+            this.account
+        )
+        return await contract.balanceOf(config.WALLET.PUBLIC_KEY);
+
+    }
+
+    /**
+     * Gets the current nonce of a wallet
+     * @returns nonce
+     */
+    getNonce = async (): Promise<number> => {
+        return await this.provider.getTransactionCount(config.WALLET.PUBLIC_KEY)
+    }
+}