@instadapp/interop-x 0.0.0-dev.ef7acff → 0.0.0-dev.f45bd03

package/src/typechain/factories/BalanceResolver__factory.ts

@@ -0,0 +1,235 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  BalanceResolver,
+  BalanceResolverInterface,
+} from "../BalanceResolver";
+
+const _abi = [
+  {
+    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",
+  },
+];
+
+export class BalanceResolver__factory {
+  static readonly abi = _abi;
+  static createInterface(): BalanceResolverInterface {
+    return new utils.Interface(_abi) as BalanceResolverInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): BalanceResolver {
+    return new Contract(address, _abi, signerOrProvider) as BalanceResolver;
+  }
+}

package/src/typechain/factories/index.ts

@@ -1,6 +1,9 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+export { AaveV2Resolver__factory } from "./AaveV2Resolver__factory";
+export { AaveV3Resolver__factory } from "./AaveV3Resolver__factory";
+export { BalanceResolver__factory } from "./BalanceResolver__factory";
 export { Erc20__factory } from "./Erc20__factory";
 export { GnosisSafe__factory } from "./GnosisSafe__factory";
 export { InstList__factory } from "./InstList__factory";

package/src/typechain/index.ts

@@ -1,11 +1,17 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+export type { AaveV2Resolver } from "./AaveV2Resolver";
+export type { AaveV3Resolver } from "./AaveV3Resolver";
+export type { BalanceResolver } from "./BalanceResolver";
 export type { Erc20 } from "./Erc20";
 export type { GnosisSafe } from "./GnosisSafe";
 export type { InstList } from "./InstList";
 export type { InteropX } from "./InteropX";
 export * as factories from "./factories";
+export { AaveV2Resolver__factory } from "./factories/AaveV2Resolver__factory";
+export { AaveV3Resolver__factory } from "./factories/AaveV3Resolver__factory";
+export { BalanceResolver__factory } from "./factories/BalanceResolver__factory";
 export { Erc20__factory } from "./factories/Erc20__factory";
 export { GnosisSafe__factory } from "./factories/GnosisSafe__factory";
 export { InstList__factory } from "./factories/InstList__factory";

package/src/utils/formatting.ts

@@ -1,3 +1,16 @@
+const locale = "en-US";
+
+export function formatUsd(value: any, fractionDigits = 0) {
+    const formatter = new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits
+    });
+
+    return formatter.format(value);
+}
+
 export function shortenHash(hash: string, length: number = 4) {
     if (!hash) return;
 
@@ -12,4 +25,44 @@ export function shortenHash(hash: string, length: number = 4) {
 
 export function short(buffer: Buffer): string {
     return buffer.toString("hex").slice(0, 8) + "...";
+}
+
+export const chainIdToName = (chainId: string | number) => {
+    switch (String(chainId)) {
+        case "1":
+            return "Mainnet";
+        case "137":
+            return "Polygon";
+        case "43114":
+            return "Avalanche";
+        default:
+            return "Mainnet";
+    }
+};
+
+export const getChainIdNativeSymbol = (chainId: string | number) => {
+    switch (String(chainId)) {
+        case "137":
+            return "MATIC";
+        case "43114":
+            return "AVAX";
+        case "1":
+            return "ETH";
+        default:
+            return "ETH";
+    }
+};
+
+
+export const getExplorerUrl = (chainId: string | number, suffix = '/') => {
+    switch (String(chainId)) {
+        case "1":
+            return `https://etherscan.io${suffix}`;
+        case "137":
+            return `https://polygonscan.com${suffix}`;
+        case "43114":
+            return `https://snowtrace.io${suffix}`;
+        default:
+            return `https://etherscan.io${suffix}`;
+    }
 }

package/src/utils/gnosis.ts

@@ -1,6 +1,8 @@
 import { addresses } from "@/constants";
+import { peerPool } from "@/net";
 import { GnosisSafe } from "@/typechain";
 import { ChainId } from "@/types";
+import { messagePrefix } from "@ethersproject/hash";
 import { ethers, Wallet } from "ethers";
 
 export interface Signature {
@@ -20,22 +22,23 @@ export const buildSignatureBytes = (signatures: Signature[]): string => {
   return signatureBytes;
 };
 
-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 }: { signer: Wallet }
-) => {
+const gnosisSignatureTypes = {
+  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" },
+  ],
+};
+
+export const getGnosisSignatureAddress = ({ signature, message, chainId }: { signature: string, message: Record<string, any>, chainId: ChainId }) => {
+
   const gnosisSafe = addresses[chainId].gnosisSafe;
 
   const domain = {
@@ -43,20 +46,24 @@ export const signGnosisSafeTx = async (
     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" },
-    ],
-  };
+  return ethers.utils.verifyTypedData(domain, gnosisSignatureTypes, message, signature)
+
+}
+
+export const generateGnosisSignatureMessage = ({
+  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,
+}) => {
+  const gnosisSafe = addresses[chainId].gnosisSafe;
 
   const message = {
     baseGas,
@@ -72,7 +79,33 @@ export const signGnosisSafeTx = async (
     value,
   };
 
-  return await signer._signTypedData(domain, types, message);
+  return message;
+}
+
+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 }: { signer: Wallet }
+) => {
+  const gnosisSafe = addresses[chainId].gnosisSafe;
+
+  const domain = {
+    verifyingContract: gnosisSafe,
+    chainId,
+  };
+
+  const message = generateGnosisSignatureMessage({ to, data, value, operation, baseGas, gasPrice, gasToken, refundReceiver, safeTxGas, nonce, chainId });
+
+  return await signer._signTypedData(domain, gnosisSignatureTypes, message);
 };
 
 export const generateGnosisTransaction = async (
@@ -120,4 +153,14 @@ export const generateGnosisTransaction = async (
   }
 
   return transactionData;
-};
+};
+
+export const getGnosisOwnerPeerIds = async ({ gnosisContract = null as unknown as GnosisSafe }) => {
+  const owners = await gnosisContract
+    .getOwners()
+    .then((owners) => owners.map((owner) => owner.toLowerCase()));
+
+  return peerPool.activePeers
+    .filter((peer) => owners.includes(peer.publicAddress.toLowerCase()))
+    .map((peer) => peer.id);
+}

package/src/utils/index.ts

@@ -6,3 +6,4 @@ export * from './http';
 export * from './interop';
 export * from './web3';
 export * from './validate';
+export * from './tokens';

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

@@ -1,5 +1,14 @@
-import { addresses } from "@/constants";
-import { InvalidChaindIdError } from "@/errors";
+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";
 
 export const validateChains = ({ sourceChainId, targetChainId }) => {
     if (!sourceChainId) {
@@ -22,3 +31,141 @@ export const validateChains = ({ sourceChainId, targetChainId }) => {
         throw new InvalidChaindIdError("Invalid target chain id");
     }
 };
+
+
+export const validateSourceLiquidity = async ({
+    position = null as unknown as IPosition,
+    sourceChainId,
+    isSupply = false,
+    sourceProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    sourceProvider = sourceProvider || new JsonRpcRetryProvider(getRpcProviderUrl(sourceChainId));
+
+
+    const sourceBalanceResolverContract = getContract(
+        addresses[sourceChainId].balanceResolver,
+        abi.balanceResolver,
+        sourceProvider,
+    )
+
+    const srcBalance = await sourceBalanceResolverContract.checkLiquidity(position, addresses[sourceChainId].interopX, 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).isZero()) == false) {
+                liquidityRequired += `- Need ${new BigNumber(a.liquidityShort).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,
+    targetProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    targetProvider = targetProvider || new JsonRpcRetryProvider(getRpcProviderUrl(targetChainId));
+
+
+    const sourceBalanceResolverContract = getContract(
+        addresses[targetChainId].balanceResolver,
+        abi.balanceResolver,
+        targetProvider,
+    )
+
+    const targetBalance = await sourceBalanceResolverContract.checkLiquidity(position, addresses[targetChainId].interopX, 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).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

@@ -1,3 +1,4 @@
+import { UnsupportedChaindIdError } from "@/errors";
 import { ChainId } from "@/types";
 import retry from "async-retry";
 import { ethers } from "ethers";
@@ -11,7 +12,7 @@ export const getRpcProviderUrl = (chainId: ChainId) => {
         case 43114:
             return "https://rpc.ankr.com/avalanche";
         default:
-            throw new Error(`Unknown chainId: ${chainId}`);
+            throw new UnsupportedChaindIdError(chainId);
     }
 };
 
@@ -25,7 +26,7 @@ export class ContractError extends Error {
 export function getContract<TContract extends ethers.Contract>(
     address: string,
     contractInterface: ethers.ContractInterface | any,
-    signerOrProvider?: ethers.Signer | ethers.providers.Provider
+    signerOrProvider: ethers.Signer | ethers.providers.Provider
 ) {
     if (
         !ethers.utils.getAddress(address) ||