@instadapp/interop-x 0.0.0-dev.20e87fa → 0.0.0-dev.2187d72

package/src/abi/balanceResolver.json

@@ -0,0 +1,211 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_wnativeToken",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "components": [
+              {
+                "internalType": "address",
+                "name": "sourceToken",
+                "type": "address"
+              },
+              {
+                "internalType": "address",
+                "name": "targetToken",
+                "type": "address"
+              },
+              {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+              }
+            ],
+            "internalType": "struct Variables.TokenInfo[]",
+            "name": "supply",
+            "type": "tuple[]"
+          },
+          {
+            "components": [
+              {
+                "internalType": "address",
+                "name": "sourceToken",
+                "type": "address"
+              },
+              {
+                "internalType": "address",
+                "name": "targetToken",
+                "type": "address"
+              },
+              {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+              }
+            ],
+            "internalType": "struct Variables.TokenInfo[]",
+            "name": "withdraw",
+            "type": "tuple[]"
+          }
+        ],
+        "internalType": "struct Variables.Position",
+        "name": "position",
+        "type": "tuple"
+      },
+      {
+        "internalType": "address",
+        "name": "liquidityContract",
+        "type": "address"
+      },
+      {
+        "internalType": "bool",
+        "name": "isSupply",
+        "type": "bool"
+      },
+      {
+        "internalType": "bool",
+        "name": "isTargetToken",
+        "type": "bool"
+      }
+    ],
+    "name": "checkLiquidity",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "bool",
+            "name": "isOk",
+            "type": "bool"
+          },
+          {
+            "components": [
+              {
+                "internalType": "address",
+                "name": "token",
+                "type": "address"
+              },
+              {
+                "internalType": "uint256",
+                "name": "liquidityAvailable",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint256",
+                "name": "liquidityShort",
+                "type": "uint256"
+              }
+            ],
+            "internalType": "struct Helpers.LiquidityData[]",
+            "name": "supply",
+            "type": "tuple[]"
+          },
+          {
+            "components": [
+              {
+                "internalType": "address",
+                "name": "token",
+                "type": "address"
+              },
+              {
+                "internalType": "uint256",
+                "name": "liquidityAvailable",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint256",
+                "name": "liquidityShort",
+                "type": "uint256"
+              }
+            ],
+            "internalType": "struct Helpers.LiquidityData[]",
+            "name": "withdraw",
+            "type": "tuple[]"
+          }
+        ],
+        "internalType": "struct Helpers.PositionData",
+        "name": "p",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address[]",
+        "name": "tokens",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "liquidityContract",
+        "type": "address"
+      }
+    ],
+    "name": "getLiquidity",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "token",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "liquidityAvailable",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "liquidityShort",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct Helpers.LiquidityData[]",
+        "name": "l",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "nativeToken",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "wnativeToken",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/abi/index.ts

@@ -3,6 +3,8 @@ import erc20 from "./erc20.json";
 import interopX from "./interopX.json";
 import { connectors } from "./connectors";
 import instList from "./instList.json";
+import balanceResolver from "./balanceResolver.json";
+import aaveV2Resolver from "./aaveV2Resolver.json";
 
 export default {
   gnosisSafe,
@@ -10,4 +12,6 @@ export default {
   interopX,
   connectors,
   instList,
+  balanceResolver,
+  aaveV2Resolver,
 };

package/src/api/index.ts

@@ -26,6 +26,14 @@ export const startApiServer = async () => {
             })
         })
 
+        server.get('/transactions/:transaction', async (req) => {
+            return await Transaction.findOne({
+                where: {
+                    transactionHash: (req.params as any).transaction
+                }
+            })
+        })
+
         await server.listen(PORT, HOST)
 
         logger.log(`RPC Server listening at http://${HOST}:${PORT}`)

package/src/constants/addresses.ts

@@ -1,3 +1,13 @@
+export type NetworkAddresses = {
+  gnosisSafe: string
+  multisend: string
+  interopX: string
+  dsaAddress: string
+  instList: string
+  aaveResolver: string
+  balanceResolver: string
+}
+
 export const addresses = {
   137: {
     gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
@@ -5,12 +15,16 @@ export const addresses = {
     interopX: '0xDB6083df37C5F224a3dF84A4B5f9fB60b6c8670a',
     dsaAddress: '0x9Fbd453a8e7a158510fBae5D9935958507cf4b19',
     instList: "0x839c2D3aDe63DF5b0b8F3E57D5e145057Ab41556",
+    aaveResolver: "0x0731c1d0154C2bE74d50e2083Df10aa531AAbb10",
+    balanceResolver: "0xecc3991846bB21717B95A593Fd86C5930A491F95",
   },
   43114: {
     gnosisSafe: '0x31d7a5194Fe60AC209Cf1Ce2d539C9A60662Ed6b',
     multisend: '0x998739BFdAAdde7C933B942a68053933098f9EDa',
     interopX: '0xA82A87096709E3D8648c9d9a22f31133bC4B6d32',
-    dsaAddress: '0x053949Af585bDF29A7bdFB97568F953770028D2b',
+    dsaAddress: '0x995e67a652d2be45a8bff438b3dfac66dfff1c46',
     instList: "0x9926955e0Dd681Dc303370C52f4Ad0a4dd061687",
+    aaveResolver: "0x7C5C59944263311a1e350E3B871B0d1d8E9A513E",
+    balanceResolver: "0xD45dFA34cEeAB567208041331F5ed9916C23b1E8",
   }
-} as Record<number, { gnosisSafe: string, multisend: string, interopX: string, dsaAddress: string, instList: string }>
+} as Record<number, NetworkAddresses>

package/src/constants/capPerChain.ts

@@ -0,0 +1,5 @@
+export const capPerChain =  {
+    "1": 100_000_000,
+    "137": 100_000_000,
+    "43114": 100_000_000,
+};

package/src/constants/index.ts

@@ -1,3 +1,5 @@
 export * from './addresses';
 export * from './tokens';
 export * from './blockConfirmations';
+export * from './wrappedNativeToken';
+export * from './capPerChain';

package/src/constants/tokens.ts

@@ -1,48 +1,48 @@
 export const tokens = {
-  // 1: [
-  //   {
-  //     aliases: ['eth'],
-  //     symbol: "ETH",
-  //     name: "Ethereum",
-  //     address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
-  //     decimals: 18,
-  //   },
-  //   {
-  //     aliases: ['weth'],
-  //     symbol: "WETH",
-  //     name: "Wrapped Ethereum",
-  //     address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-  //     decimals: 18,
-  //   },
-  //   {
-  //     aliases: ['dai'],
-  //     symbol: "DAI",
-  //     name: "DAI Stable",
-  //     address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-  //     decimals: 18,
-  //   },
-  //   {
-  //     aliases: ['usdc'],
-  //     symbol: "USDC",
-  //     name: "USD Coin",
-  //     address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-  //     decimals: 6,
-  //   },
-  //   {
-  //     aliases: ['usdt'],
-  //     symbol: "USDT",
-  //     name: "Tether USD Coin",
-  //     address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-  //     decimals: 6,
-  //   },
-  //   {
-  //     aliases: ['wbtc'],
-  //     symbol: "WBTC",
-  //     name: "Wrapped BTC",
-  //     address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
-  //     decimals: 8,
-  //   },
-  // ],
+  1: [
+    {
+      aliases: ['eth'],
+      symbol: "ETH",
+      name: "Ethereum",
+      address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+      decimals: 18,
+    },
+    {
+      aliases: ['weth'],
+      symbol: "WETH",
+      name: "Wrapped Ethereum",
+      address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+      decimals: 18,
+    },
+    {
+      aliases: ['dai'],
+      symbol: "DAI",
+      name: "DAI Stable",
+      address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+      decimals: 18,
+    },
+    {
+      aliases: ['usdc'],
+      symbol: "USDC",
+      name: "USD Coin",
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      decimals: 6,
+    },
+    {
+      aliases: ['usdt'],
+      symbol: "USDT",
+      name: "Tether USD Coin",
+      address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      decimals: 6,
+    },
+    {
+      aliases: ['wbtc'],
+      symbol: "WBTC",
+      name: "Wrapped BTC",
+      address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      decimals: 8,
+    },
+  ],
   137: [
     {
       aliases: ['eth', 'weth'],

package/src/constants/wrappedNativeToken.ts

@@ -0,0 +1,5 @@
+export const wrappedNativeToken = {
+  "1": '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  "137": '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
+  "43114": '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7'
+};

package/src/crons/index.ts

@@ -0,0 +1 @@
+import "./prices"

package/src/crons/prices.ts

@@ -0,0 +1,12 @@
+import { Prices } from "@/services";
+import cron from "node-cron";
+
+Prices.fetch().catch(console.log);
+
+cron.schedule(`* * * * *`, async () => {
+    try {
+        await Prices.fetch();
+    } catch (error) {
+        console.log("Prices: ", error.message);
+    }
+});

package/src/db/models/transaction.ts

@@ -83,6 +83,22 @@ export class Transaction extends Model<
     metadata: string;
   }>;
 
+  declare executeEvent: CreationOptional<{
+    sourceSpells: Array<{ connector: string; data: string }>;
+    targetSpells: Array<{ connector: string; data: string }>;
+    position: IPosition;
+    actionId: string;
+    actionIdHashHash: string;
+    actionIdHash: string;
+    sourceSender: string;
+    sourceDsaId: string;
+    targetDsaId: string;
+    sourceChainId: number;
+    targetChainId: number;
+    vnonce: string;
+    metadata: string;
+  }>;
+
   declare status: CreationOptional<string>;
 
   declare createdAt: CreationOptional<Date>;
@@ -158,6 +174,11 @@ Transaction.init(
       allowNull: true,
     },
 
+    executeEvent: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+
     status: {
       type: DataTypes.STRING,
       defaultValue: "pending",

package/src/errors/index.ts

@@ -0,0 +1,26 @@
+export class UnsupportedChaindIdError extends Error {
+    constructor(chainId: any) {
+        super(`Unsupported chainId: ${chainId}`);
+    }
+}
+
+export class LiquidityError extends Error {
+    constructor(message?: string) {
+        super(message || "Not enough liquidity");
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+export class InvalidChaindIdError extends Error {
+    constructor(message?: string) {
+        super(message || "Invalid chain id");
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+export class LowLiquidityError extends Error {
+    constructor(message?: string) {
+        super(message || "Low liquidity");
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/src/gnosis/actions/aaveV2/source.ts

@@ -2,6 +2,7 @@ import abi from "@/abi";
 import config from "@/config";
 import { addresses } from "@/constants";
 import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
 import { InteropX } from "@/typechain";
 import { ChainId } from "@/types";
 import { encodeConnectorMethod, getContract, getRpcProviderUrl } from "@/utils";
@@ -25,7 +26,7 @@ export default async function (transaction: Transaction) {
     metadata,
   } = transaction.submitEvent;
 
-  const sourceChainProvider = new ethers.providers.JsonRpcProvider(
+  const sourceChainProvider = new JsonRpcRetryProvider(
     getRpcProviderUrl(sourceChainId as ChainId)
   );
   const sourceWallet = new ethers.Wallet(

package/src/gnosis/actions/aaveV2/target.ts

@@ -2,6 +2,7 @@ import abi from "@/abi";
 import config from "@/config";
 import { addresses } from "@/constants";
 import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
 import { InteropX } from "@/typechain";
 import { InstList } from "@/typechain/InstList";
 import { ChainId } from "@/types";
@@ -27,7 +28,7 @@ export default async function (transaction: Transaction) {
         metadata,
     } = transaction.validateEvent;
 
-    const targetChainProvider = new ethers.providers.JsonRpcProvider(
+    const targetChainProvider = new JsonRpcRetryProvider(
         getRpcProviderUrl(targetChainId as ChainId)
     );
     const targetWallet = new ethers.Wallet(
@@ -38,7 +39,8 @@ export default async function (transaction: Transaction) {
 
     const targetInstListContract = getContract<InstList>(
         addresses[targetChainId].instList,
-        abi.instList ,
+        abi.instList,
+        targetChainProvider,
     );
 
     const targetDsaAddress = await targetInstListContract.accountAddr(targetDsaId)

package/src/index.ts

@@ -82,6 +82,7 @@ import { startPeer, protocol, peerPool } from "@/net";
 import { startApiServer } from '@/api';
 import { Transaction } from './db';
 import { shortenHash } from './utils';
+import './crons';
 
 async function main() {
 

package/src/providers/index.ts

@@ -0,0 +1 @@
+export * from './retry-provider';

package/src/providers/retry-provider.ts

@@ -0,0 +1,51 @@
+import { ethers } from "ethers";
+import wait from "waait";
+import Bluebird from "bluebird";
+
+export interface RetryOptions {
+    delay?: number;
+    timeouts: number[];
+}
+
+export function promiseTimeout<T>(ms: number, promise: Promise<T>): Promise<T> {
+    return Bluebird.resolve(promise).timeout(ms);
+}
+
+export function retryOperation(
+    retriesLeft: number,
+    operation: () => Promise<any>,
+    options: RetryOptions
+) {
+    return new Promise((resolve, reject) => {
+        const { timeouts } = options;
+        // Find the timeout for this specific iteration
+        const timeout = timeouts[timeouts.length - retriesLeft];
+
+        // Wrap the original operation in a timeout
+        const execution = promiseTimeout(timeout, operation());
+
+        // If the promise is successful, resolve it and bubble the result up
+        return execution.then(resolve).catch((reason: any) => {
+            // If there are any retries left, we call the same retryOperation function again,
+            // but decrementing the number of retries left by 1
+            if (retriesLeft - 1 > 0) {
+                // Delay the new attempt slightly
+                return wait(options.delay || 50)
+                    .then(retryOperation.bind(null, retriesLeft - 1, operation, options))
+                    .then(resolve)
+                    .catch(reject);
+            }
+            // Reject (and bubble the result up) if there are no more retries
+            return reject(reason);
+        });
+    });
+}
+
+export class JsonRpcRetryProvider extends ethers.providers.JsonRpcProvider {
+    public perform(method: string, params: any): Promise<any> {
+        const timeouts = [5_000, 10_000];
+        const operation = () => super.perform(method, params);
+
+        return retryOperation(2, operation, { timeouts, delay: 50 });
+    }
+}

package/src/services/Prices.ts

@@ -0,0 +1,89 @@
+import Web3Utils from "web3-utils";
+import path from "path";
+import fs from "fs";
+import { tokens } from "@/constants";
+import expandHomeDir from "expand-home-dir";
+import config from "@/config";
+import { http } from "@/utils";
+
+const basePath = expandHomeDir(`~/.interop-x/data/${config.publicAddress}/${config.staging ? 'staging' : ''}`);
+const mainnetPricesFilePath = path.resolve(basePath, "./mainnetPrices.json");
+const networkTokenPricesFilePath = path.resolve(basePath, "./networkTokenPrices.json");
+
+class Prices {
+  private static mainnetPrices = {};
+
+  private static networkTokenPrices = {};
+
+  static async fetch() {
+
+    if (!fs.existsSync(mainnetPricesFilePath)) {
+      fs.writeFileSync(mainnetPricesFilePath, JSON.stringify({}));
+    }
+
+    if (!fs.existsSync(networkTokenPricesFilePath)) {
+      fs.writeFileSync(networkTokenPricesFilePath, JSON.stringify({}));
+    }
+
+    this.mainnetPrices = JSON.parse(fs.readFileSync(mainnetPricesFilePath, "utf8"));
+    this.networkTokenPrices = JSON.parse(fs.readFileSync(networkTokenPricesFilePath, "utf8"));
+
+    try {
+      const path = tokens["1"]
+        .filter((a) => a.symbol !== "ETH")
+        .map((token) => token.address)
+        .join(",");
+
+      const [response, ethResponse, avaxResponse, polygonResponse] =
+        await Promise.all([
+          http.get(
+            "https://api.coingecko.com/api/v3/simple/token_price/ethereum",
+            {
+              params: { contract_addresses: path, vs_currencies: "usd" },
+            }
+          ),
+          http.get("https://api.coingecko.com/api/v3/simple/price", {
+            params: { ids: "ethereum", vs_currencies: "usd" },
+          }),
+          http.get("https://api.coingecko.com/api/v3/simple/price", {
+            params: { ids: "avalanche-2", vs_currencies: "usd" },
+          }),
+          http.get("https://api.coingecko.com/api/v3/simple/price", {
+            params: { ids: "matic-network", vs_currencies: "usd" },
+          }),
+        ]);
+
+      this.networkTokenPrices = {
+        "1": ethResponse.data.ethereum.usd.toString(),
+        "137": polygonResponse.data["matic-network"].usd.toString(),
+        "43114": avaxResponse.data["avalanche-2"].usd.toString(),
+      };
+
+      const data = response.data;
+
+      for (const key in data) {
+        const _key = Web3Utils.toChecksumAddress(key);
+        if (!data[key].usd) continue;
+        this.mainnetPrices[_key] = data[key].usd.toString();
+      }
+
+      this.mainnetPrices["0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"] =
+        ethResponse.data.ethereum.usd.toString();
+    } catch (error) { }
+
+    fs.writeFileSync(mainnetPricesFilePath, JSON.stringify(this.mainnetPrices));
+    fs.writeFileSync(networkTokenPricesFilePath, JSON.stringify(this.networkTokenPrices));
+
+    return this.mainnetPrices;
+  }
+
+  static getMainnetPrices() {
+    return this.mainnetPrices;
+  }
+
+  static getNetworkTokenPrices() {
+    return this.networkTokenPrices;
+  }
+}
+
+export default Prices;

package/src/services/index.ts

@@ -0,0 +1 @@
+export { default as Prices } from './Prices';