@instadapp/interop-x 0.0.0-dev.0bace53 → 0.0.0-dev.0ca1aa1

package/src/utils/http.ts

@@ -0,0 +1,6 @@
+import axios from "axios";
+import axiosRetry from "axios-retry";
+
+export const http = axios.create();
+
+axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });

package/src/utils/index.ts

@@ -1,240 +1,10 @@
-/**
- * @module util
- */
-import axios from 'axios'
-import axiosRetry from "axios-retry";
-import { addresses } from '@/constants';
-import { ChainId } from '@/types'
-import { ethers } from 'ethers';
-import { GnosisSafe } from '@/typechain';
-export const http = axios.create();
-
-axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
-
-
-export function shortenHash(hash: string, length: number = 4) {
-  if (!hash) return;
-
-  if (hash.length < 12) return hash;
-
-  const beginningChars = hash.startsWith("0x") ? length + 2 : length;
-
-  const shortened = hash.substr(0, beginningChars) + "…" + hash.substr(-length);
-
-  return shortened;
-}
-
-export function short(buffer: Buffer): string {
-  return buffer.toString('hex').slice(0, 8) + '...'
-}
-
-export const signGnosisSafeTx = async ({
-  to,
-  data = null as any,
-  value = '0',
-  operation = '1',
-  baseGas = '0',
-  gasPrice = "0",
-  gasToken = "0x0000000000000000000000000000000000000000",
-  refundReceiver = "0x0000000000000000000000000000000000000000",
-  safeTxGas = "79668" as string | number,
-  nonce = "0",
-  chainId = 137 as ChainId,
-}, { signer }) => {
-  const gnosisSafe = addresses[chainId].gnosisSafe;
-
-  const domain = {
-    verifyingContract: gnosisSafe,
-    chainId,
-  };
-
-  const types = {
-    SafeTx: [
-      { type: 'address', name: 'to' },
-      { type: 'uint256', name: 'value' },
-      { type: 'bytes', name: 'data' },
-      { type: 'uint8', name: 'operation' },
-      { type: 'uint256', name: 'safeTxGas' },
-      { type: 'uint256', name: 'baseGas' },
-      { type: 'uint256', name: 'gasPrice' },
-      { type: 'address', name: 'gasToken' },
-      { type: 'address', name: 'refundReceiver' },
-      { type: 'uint256', name: 'nonce' },
-    ],
-  };
-
-  const message = {
-    baseGas,
-    data,
-    gasPrice,
-    gasToken,
-    nonce: Number(nonce),
-    operation,
-    refundReceiver,
-    safeAddress: gnosisSafe,
-    safeTxGas: String(safeTxGas),
-    to,
-    value,
-  };
-
-  return await signer._signTypedData(domain, types, message)
-};
-
-export const getRpcProviderUrl = (chainId: ChainId) => {
-  switch (chainId) {
-    case 1:
-      return 'https://rpc.ankr.com/eth';
-    case 137:
-      return 'https://rpc.ankr.com/polygon';
-    case 43114:
-      return 'https://rpc.ankr.com/avalanche';
-    default:
-      throw new Error(`Unknown chainId: ${chainId}`);
-  }
-}
-
-export interface Signature {
-  signer: string;
-  hash?: string;
-  data: string;
-}
-
-export const buildSignatureBytes = (signatures: Signature[]): string => {
-  signatures.sort((left, right) =>
-    left.signer.toLowerCase().localeCompare(right.signer.toLowerCase())
-  );
-  let signatureBytes = "0x";
-  for (const sig of signatures) {
-    signatureBytes += sig.data.slice(2);
-  }
-  return signatureBytes;
-};
-
-/**
- * Call an async function with a maximum time limit (in milliseconds) for the timeout
- *  Resolved promise for async function call, or an error if time limit reached
- */
-export const asyncCallWithTimeout = async <T>(asyncPromise: Promise<T>, timeout: number) => {
-  let timeoutHandle;
-
-  const timeoutPromise = new Promise((_resolve, reject) => {
-    timeoutHandle = setTimeout(
-      () => reject(new Error('Async call timeout limit reached')),
-      timeout
-    );
-  });
-
-  return Promise.race([asyncPromise, timeoutPromise]).then(result => {
-    clearTimeout(timeoutHandle);
-    return result;
-  }) as Promise<T>
-}
-
-
-export const generateInteropTransactionHash = (data: { action: string, bridger: string, requestTransactionHash: string, sourceChainId: string | number, targetChainId: string | number }) => {
-  return ethers.utils.solidityKeccak256(['string', 'string', 'string', 'string', 'string'], [
-    String(data.action),
-    String(data.bridger),
-    String(data.requestTransactionHash),
-    String(data.sourceChainId),
-    String(data.targetChainId),
-  ]);
-}
-
-export function getContract<TContract extends ethers.Contract>(address: string, contractInterface: ethers.ContractInterface | any, signerOrProvider?: ethers.Signer | ethers.providers.Provider) {
-  if (!ethers.utils.getAddress(address) || address === ethers.constants.AddressZero) {
-    throw Error(`Invalid 'address' parameter '${address}'.`)
-  }
-
-  const contract = new ethers.Contract(
-    address,
-    contractInterface,
-    signerOrProvider
-  ) as TContract
-
-  // Make sure the contract properties is writable
-  const desc = Object.getOwnPropertyDescriptor(contract, 'functions');
-
-  if (!desc || desc.writable !== true) {
-    return contract
-  }
-
-  return new Proxy(contract, {
-    get(target, prop, receiver) {
-      const value = Reflect.get(target, prop, receiver);
-
-      if (typeof value === 'function' && (contract.functions.hasOwnProperty(prop) || ['queryFilter'].includes(String(prop)))) {
-        return async (...args: any[]) => {
-          try {
-            return await value.bind(contract)(...args);
-          } catch (error) {
-            throw new Error(`Error calling "${String(prop)}" on "${address}": ${error.reason || error.message}`)
-          }
-        }
-      }
-
-
-      if (typeof value === 'object' && ['populateTransaction', 'estimateGas', 'functions', 'callStatic'].includes(String(prop))) {
-        const parentProp = String(prop);
-
-        return new Proxy(value, {
-          get(target, prop, receiver) {
-            const value = Reflect.get(target, prop, receiver);
-
-            if (typeof value === 'function') {
-              return async (...args: any[]) => {
-                try {
-                  return await value.bind(contract)(...args);
-                } catch (error) {
-                  throw new Error(`Error calling "${String(prop)}" using "${parentProp}" on "${address}": ${error.reason || error.message}`)
-                }
-              }
-            }
-          }
-        })
-      }
-
-      return value;
-    },
-  });
-}
-
-export const generateGnosisTransaction = async (transactionData: any, safeContract: GnosisSafe) => {
-  console.log(transactionData);
-
-  let isExecuted = await safeContract.dataHashes(
-      await safeContract.getTransactionHash(
-          transactionData.to,
-          transactionData.value,
-          transactionData.data,
-          transactionData.operation,
-          transactionData.safeTxGas,
-          transactionData.baseGas,
-          transactionData.gasPrice,
-          transactionData.gasToken,
-          transactionData.refundReceiver,
-          transactionData.nonce
-      )
-  )
-
-  while (isExecuted == 1) {
-      transactionData.safeTxGas = ethers.BigNumber.from(String(transactionData.safeTxGas)).add(1).toString()
-
-      isExecuted = await safeContract.dataHashes(
-          await safeContract.getTransactionHash(
-              transactionData.to,
-              transactionData.value,
-              transactionData.data,
-              transactionData.operation,
-              transactionData.safeTxGas,
-              transactionData.baseGas,
-              transactionData.gasPrice,
-              transactionData.gasToken,
-              transactionData.refundReceiver,
-              transactionData.nonce
-          )
-      )
-  }
-
-  return transactionData
-}
+export * from './async';
+export * from './dsa';
+export * from './formatting';
+export * from './gnosis';
+export * from './http';
+export * from './interop';
+export * from './web3';
+export * from './validate';
+export * from './tokens';
+export * from './aave';

package/src/utils/interop.ts

@@ -0,0 +1,28 @@
+import { ethers } from "ethers";
+
+type GenerateInteropTransactionHashParam = {
+    actionId: string;
+    vnonce: string;
+    sourceSender: string;
+    sourceChainId: string | number;
+    sourceDsaId: string;
+    targetChainId: string | number;
+    targetDsaId: string;
+};
+
+export const generateInteropTransactionHash = (
+    data: GenerateInteropTransactionHashParam
+) => {
+    return ethers.utils.solidityKeccak256(
+        Array.from({ length: 7 }, () => "string"),
+        [
+            String(data.actionId),
+            String(data.vnonce),
+            String(data.sourceSender),
+            String(data.sourceChainId),
+            String(data.sourceDsaId),
+            String(data.targetChainId),
+            String(data.targetDsaId),
+        ]
+    );
+};

package/src/utils/tokens.ts

@@ -0,0 +1,21 @@
+import { wrappedNativeToken } from "@/constants"
+
+export const isNativeToken = (tokenAddress: string) => {
+    return tokenAddress.toLowerCase() === "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE".toLowerCase()
+}
+
+export const isNativeWrappedToken = (tokenAddress: string, chainId: number | string) => {
+    return wrappedNativeToken[chainId].toLowerCase() == tokenAddress.toLowerCase()
+}
+
+export const isNativeOrWrappedToken = (tokenAddress: string, chainId: number | string) => {
+    if (isNativeToken(tokenAddress)) {
+        return true
+    }
+
+    if (isNativeWrappedToken(tokenAddress, chainId)) {
+        return true
+    }
+
+    return false
+}

package/src/utils/validate.ts

@@ -0,0 +1,179 @@
+import abi from "@/abi";
+import { addresses, capPerChain, tokens } from "@/constants";
+import { InvalidChaindIdError, LowLiquidityError } from "@/errors";
+import { ethers } from "ethers";
+import { getContract, getRpcProviderUrl } from "./web3";
+import BigNumber from "bignumber.js";
+import { chainIdToName, formatUsd } from "./formatting";
+import { isNativeWrappedToken } from "./tokens";
+import { Prices } from "@/services";
+import { JsonRpcRetryProvider } from "@/providers";
+import { IPosition } from "@/db";
+import { BalanceResolver } from "@/typechain";
+import { getDsaAccountAddress } from "./dsa";
+
+export const validateChains = ({ sourceChainId, targetChainId }) => {
+    if (!sourceChainId) {
+        throw new InvalidChaindIdError("Source chain id is required");
+    }
+
+    if (!targetChainId) {
+        throw new InvalidChaindIdError("Target chain id is required");
+    }
+
+    if (sourceChainId == targetChainId) {
+        throw new InvalidChaindIdError("Source and target chain cannot be the same");
+    }
+
+    if (!addresses[sourceChainId]) {
+        throw new InvalidChaindIdError("Invalid source chain id");
+    }
+
+    if (!addresses[targetChainId]) {
+        throw new InvalidChaindIdError("Invalid target chain id");
+    }
+};
+
+
+export const validateSourceLiquidity = async ({
+    position = null as unknown as IPosition,
+    sourceChainId,
+    sourceDsaId,
+    isSupply = false,
+    sourceProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    sourceProvider = sourceProvider || new JsonRpcRetryProvider(getRpcProviderUrl(sourceChainId));
+
+
+    const sourceBalanceResolverContract = getContract<BalanceResolver>(
+        addresses[sourceChainId].balanceResolver,
+        abi.balanceResolver,
+        sourceProvider,
+    )
+
+    const srcDsaAddress = await getDsaAccountAddress({ dsaId: sourceDsaId, chainId: sourceChainId , provider: sourceProvider });
+    const srcBalance = await sourceBalanceResolverContract.checkLiquidity(position, srcDsaAddress, isSupply, false)
+
+    if (!srcBalance.isOk) {
+
+        let liquidityRequired = ""
+
+        srcBalance.withdraw.forEach(a => {
+            const token = tokens[sourceChainId].find(t => t.address.toLowerCase() === a.token.toLowerCase());
+
+            if (token && (new BigNumber(a.liquidityShort.toString()).isZero()) == false) {
+                liquidityRequired += `- Need ${new BigNumber(a.liquidityShort.toString()).dividedBy(10 ** token.decimals).toFormat()} ${token.symbol}\n`
+            }
+        })
+
+        throw new LowLiquidityError(`Liquidity low on ${chainIdToName(sourceChainId)}: \n` + liquidityRequired);
+    }
+};
+
+export const validateTargetLiquidity = async ({
+    position = null as unknown as IPosition,
+    targetChainId,
+    targetDsaId,
+    targetProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    targetProvider = targetProvider || new JsonRpcRetryProvider(getRpcProviderUrl(targetChainId));
+
+
+    const sourceBalanceResolverContract = getContract<BalanceResolver>(
+        addresses[targetChainId].balanceResolver,
+        abi.balanceResolver,
+        targetProvider,
+    )
+    // TODO:
+
+    const targetDsaAddress = await getDsaAccountAddress({ dsaId: targetDsaId, chainId: targetChainId, provider: targetProvider });
+
+    const targetBalance = await sourceBalanceResolverContract.checkLiquidity(position, targetDsaAddress, true, true)
+
+    if (!targetBalance.isOk) {
+
+        let liquidityRequired = ""
+
+        targetBalance.supply.forEach(a => {
+            const token = tokens[targetChainId].find(t => t.address.toLowerCase() === a.token.toLowerCase());
+
+
+            if (token) {
+                liquidityRequired += `- Need ${new BigNumber(a.liquidityShort.toString()).dividedBy(10 ** token.decimals).toFormat()} ${token.symbol}\n`
+            }
+        })
+
+        throw new LowLiquidityError(`Liquidity low on ${chainIdToName(targetChainId)}: \n` + liquidityRequired);
+    }
+};
+
+const mapTokenAddressToMainnetToken = (
+    address: string,
+    targetChainId: number | string
+) => {
+    targetChainId = String(targetChainId);
+    const token = tokens[targetChainId].find(
+        (t) => t.address.toLowerCase() === address.toLowerCase()
+    );
+
+    if (targetChainId === "1") {
+        return token;
+    }
+
+    if (!token) {
+        return null;
+    }
+
+    return tokens["1"].find((t) => t.symbol === token.symbol);
+};
+
+export const validateLiquidityCap = async (
+    position: IPosition,
+    sourceChainId: number | string,
+    targetChainId: number | string
+) => {
+    const cap = capPerChain[targetChainId] || 1_000_000;
+    const mainnetPrices = Prices.getMainnetPrices();
+    const nativeTokenPrice = Prices.getNetworkTokenPrices()[targetChainId];
+
+    let total = new BigNumber(0);
+
+    const supplyPosition = position.supply;
+
+    for (const { sourceToken: srcTokenAddress, targetToken: tokenAddress, amount } of supplyPosition) {
+        let tokenPrice;
+        let token;
+
+        if (isNativeWrappedToken(srcTokenAddress, sourceChainId)) {
+            tokenPrice = nativeTokenPrice;
+            token = tokens[targetChainId].find(t => t.address === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE');
+        } else {
+            const mainnetToken = mapTokenAddressToMainnetToken(
+                tokenAddress,
+                targetChainId
+            );
+            if (!mainnetToken) {
+                throw new Error(`Token ${tokenAddress} is not valid.`);
+            }
+
+            tokenPrice = mainnetPrices[mainnetToken.address];
+
+            if (!tokenPrice) {
+                throw new Error(`Token ${tokenAddress} is not valid!`);
+            }
+
+            token = mainnetToken;
+        }
+
+
+        total = total.plus((tokenPrice * Number(amount)) / 10 ** token.decimals);
+    }
+
+    if (total.isGreaterThan(cap)) {
+        throw new Error(
+            `Total amount of tokens in the transaction is greater than the maximum limit of estimated ${formatUsd(
+                cap
+            )}`
+        );
+    }
+};

package/src/utils/web3.ts

@@ -0,0 +1,145 @@
+import { UnsupportedChaindIdError } from "@/errors";
+import { ChainId } from "@/types";
+import retry from "async-retry";
+import { ethers } from "ethers";
+
+export const getRpcProviderUrl = (chainId: ChainId | string) => {
+    switch (String(chainId)) {
+        case "1":
+            return "https://rpc.ankr.com/eth";
+        case "137":
+            return "https://rpc.ankr.com/polygon";
+        case "43114":
+            return "https://rpc.ankr.com/avalanche";
+        default:
+            throw new UnsupportedChaindIdError(chainId);
+    }
+};
+
+export const chainIdToNetwork = (chainId: ChainId | string) => {
+    switch (String(chainId)) {
+        case "1":
+            return "mainnet";
+        case "137":
+            return "polygon";
+        case "43114":
+            return "avalanche";
+        default:
+            throw new UnsupportedChaindIdError(chainId);
+    }
+}
+
+
+export class ContractError extends Error {
+    method: string;
+    address: string;
+    args: any[];
+}
+
+export function getContract<TContract extends ethers.Contract>(
+    address: string,
+    contractInterface: ethers.ContractInterface | any,
+    signerOrProvider: ethers.Signer | ethers.providers.Provider
+) {
+    if (
+        !ethers.utils.getAddress(address) ||
+        address === ethers.constants.AddressZero
+    ) {
+        throw Error(`Invalid 'address' parameter '${address}'.`);
+    }
+
+    const contract = new ethers.Contract(
+        address,
+        contractInterface,
+        signerOrProvider
+    ) as TContract;
+
+    // Make sure the contract properties is writable
+    const desc = Object.getOwnPropertyDescriptor(contract, "functions");
+
+    if (!desc || desc.writable !== true) {
+        return contract;
+    }
+
+    return new Proxy(contract, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+
+            if (
+                typeof value === "function" &&
+                (contract.functions.hasOwnProperty(prop) ||
+                    ["queryFilter"].includes(String(prop)))
+            ) {
+                let isConstant = false;
+
+                try {
+                    isConstant = contract.interface.getFunction(String(prop)).constant;
+                } catch (error) { }
+
+                return async (...args: any[]) => {
+                    try {
+                        return await retry(
+                            async () => await value.bind(contract)(...args),
+                            { retries: isConstant ? 1 : 3 }
+                        );
+                    } catch (error) {
+                        const err = new ContractError(
+                            `Error calling "${String(prop)}" on "${address}": ${error.reason || error.message
+                            }`
+                        );
+
+                        err.method = String(prop);
+                        err.address = address;
+                        err.args = [...args];
+
+                        throw err;
+                    }
+                };
+            }
+
+            if (
+                typeof value === "object" &&
+                [
+                    "populateTransaction",
+                    "estimateGas",
+                    "functions",
+                    "callStatic",
+                ].includes(String(prop))
+            ) {
+                const parentProp = String(prop);
+
+                return new Proxy(value, {
+                    get(target, prop, receiver) {
+                        const value = Reflect.get(target, prop, receiver);
+
+                        if (typeof value === "function") {
+                            return async (...args: any[]) => {
+                                try {
+                                    return await retry(
+                                        async () => await value.bind(contract)(...args),
+                                        { retries: parentProp === "callStatic" ? 3 : 1 }
+                                    );
+                                } catch (error) {
+                                    const err = new ContractError(
+                                        `Error calling "${String(
+                                            prop
+                                        )}" using "${parentProp}" on "${address}": ${error.reason || error.message
+                                        }`
+                                    );
+
+                                    err.method = String(prop);
+                                    err.address = address;
+                                    err.args = [...args];
+
+                                    throw err;
+                                }
+                            };
+                        }
+                    },
+                });
+            }
+
+            return value;
+        },
+    });
+}

package/tests/aaveV3ValidateCrossChainPosition.ts

@@ -0,0 +1,15 @@
+
+import "../src/alias"
+import dotenv from "dotenv";
+dotenv.config();
+
+import { aaveV3ValidateCrossChainPosition } from "../src/utils"
+
+aaveV3ValidateCrossChainPosition({
+    sourceAddress: '0x15429B6FC30FA2eB44C80884cFe4C50960283D1f',
+    targetAddress: '0x15429B6FC30FA2eB44C80884cFe4C50960283D1f',
+    sourceChainId: 137,
+    targetChainId: 43114,
+})
+    .then(() => console.log('No issues'))
+    .catch((e) => console.log(String(e)));