@instadapp/interop-x 0.0.0-dev.e53015f → 0.0.0-dev.ea4acf6

package/src/typechain/factories/index.ts

@@ -1,7 +1,10 @@
 /* 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 { InteropBridgeToken__factory } from "./InteropBridgeToken__factory";
-export { InteropXGateway__factory } from "./InteropXGateway__factory";
+export { InstList__factory } from "./InstList__factory";
+export { InteropX__factory } from "./InteropX__factory";

package/src/typechain/index.ts

@@ -1,12 +1,18 @@
 /* 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 { InteropBridgeToken } from "./InteropBridgeToken";
-export type { InteropXGateway } from "./InteropXGateway";
+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 { InteropBridgeToken__factory } from "./factories/InteropBridgeToken__factory";
-export { InteropXGateway__factory } from "./factories/InteropXGateway__factory";
+export { InstList__factory } from "./factories/InstList__factory";
+export { InteropX__factory } from "./factories/InteropX__factory";

package/src/utils/async.ts

@@ -0,0 +1,22 @@
+/**
+ * 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>;
+};

package/src/utils/dsa.ts

@@ -0,0 +1,56 @@
+import Web3EthAbi from "web3-eth-abi";
+import { connectors } from "@/abi/connectors";
+import { getContract, getRpcProviderUrl } from "./web3";
+import { InstList } from "@/typechain";
+import { addresses } from "@/constants";
+import abi from "@/abi";
+import { JsonRpcRetryProvider } from "@/providers";
+import { ChainId } from "@/types";
+import { ethers } from "ethers";
+
+export const encodeConnectorMethod = (params: {
+    connector: string;
+    method: string;
+    args: string[];
+}) => {
+    const connectorInterface = getInterface(
+        connectors.versions[2][params.connector],
+        params.method
+    );
+
+    if (!connectorInterface)
+        throw new Error(`ConnectorInterface '${params.method}' not found`);
+
+    //@ts-ignore
+    return Web3EthAbi.encodeFunctionCall(connectorInterface, params.args);
+};
+
+const getInterface = (abiItems: any[], method: string) => {
+    const abiItem = abiItems.find((abiItem) => abiItem.name === method);
+
+    if (!abiItem) {
+        console.error(`${method} is an invalid method.`);
+        return;
+    }
+
+    return abiItem;
+};
+
+
+export const getDsaAccountAddress = async ({
+    dsaId,
+    chainId,
+    provider = null as ethers.providers.Provider | null,
+}) => {
+    if (!dsaId) throw new Error("DSA id is required");
+
+    provider = provider || new JsonRpcRetryProvider(getRpcProviderUrl(chainId));
+
+    const instListContract = getContract<InstList>(
+        addresses[chainId].instList,
+        abi.instList,
+        provider,
+    );
+
+    return await instListContract.accountAddr(dsaId)
+}

package/src/utils/formatting.ts

@@ -0,0 +1,68 @@
+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;
+
+    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 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

@@ -0,0 +1,166 @@
+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 {
+  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;
+};
+
+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 = {
+    verifyingContract: gnosisSafe,
+    chainId,
+  };
+
+  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,
+    data,
+    gasPrice,
+    gasToken,
+    nonce: Number(nonce),
+    operation,
+    refundReceiver,
+    safeAddress: gnosisSafe,
+    safeTxGas: String(safeTxGas),
+    to,
+    value,
+  };
+
+  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 (
+  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 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/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,319 +1,9 @@
-/**
- * @module util
- */
-import axios from 'axios'
-import axiosRetry from "axios-retry";
-import { addresses, itokens, tokens } from '@/constants';
-import { ChainId } from '@/types'
-import { ethers } from 'ethers';
-import { encodeMulti, MetaTransaction, OperationType } from 'ethers-multisend';
-import { Transaction } from '@/db';
-import config from '@/config';
-import abi from '@/abi';
-import { InteropBridgeToken, InteropXGateway } 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, submitTransactionHash: string, sourceChainId: string | number, targetChainId: string | number }) => {
-  return ethers.utils.solidityKeccak256(['string', 'string', 'string', 'string'], [
-    String(data.action),
-    String(data.submitTransactionHash),
-    String(data.sourceChainId),
-    String(data.targetChainId),
-  ]);
-}
-
-export const buildDataForTransaction = async (transaction: Transaction, type?: 'source' | 'target') => {
-  type = type || transaction.sourceStatus === 'pending' ? 'source' : 'target';
-
-  switch (transaction.action) {
-    case "deposit":
-      return await buildDepositDataForTransaction(transaction, type);
-    case "withdraw":
-      return await buildWithdrawDataForTransaction(transaction, type);
-    default:
-      throw new Error(`Unknown action: ${transaction.action}`);
-  }
-}
-
-export const buildDepositDataForTransaction = async (transaction: Transaction, type: 'source' | 'target') => {
-  const transactions: MetaTransaction[] = [];
-
-  if (transaction.action !== 'deposit') {
-    throw new Error(`Invalid action: ${transaction.action}`)
-  }
-
-  if (transaction.action === 'deposit' && transaction.sourceStatus === 'pending') {
-    throw Error('Cannot build data for pending deposit transaction');
-  }
-
-  if (!transaction.submitEvent) {
-    throw Error('Cannot build data for transaction without submitEvent');
-  }
-
-
-  const token = tokens[transaction.sourceChainId].find(token => token.address.toLowerCase() === transaction.submitEvent.token.toLowerCase());
-
-  if (!token) {
-    throw Error('Cannot build data for transaction without token');
-  }
-
-  const itoken = itokens[transaction.targetChainId].find(itoken => itoken.symbol.toLowerCase() === token.symbol.toLowerCase());
-
-  if (!itoken) {
-    throw Error('Cannot build data for transaction without itoken');
-  }
-
-  const targetChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(transaction.targetChainId as ChainId));
-  const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
-  const interopBridgeContract = getContract<InteropBridgeToken>(itoken.address, abi.interopBridgeToken, targetWallet);
-
-  const { data } = await interopBridgeContract.populateTransaction.mint(
-    transaction.submitEvent.user,
-    ethers.BigNumber.from(transaction.submitEvent.amount.toString()),
-    ethers.BigNumber.from(transaction.submitEvent.sourceChainId.toString()),
-    transaction.submitTransactionHash,
-  );
-
-  transactions.push({
-    to: itoken.address,
-    data: data!,
-    value: '0',
-    operation: OperationType.Call,
-  });
-
-  return encodeMulti(transactions).data
-}
-
-export const buildWithdrawDataForTransaction = async (transaction: Transaction, type: 'source' | 'target') => {
-  const transactions: MetaTransaction[] = [];
-
-  if (transaction.action !== 'withdraw') {
-    throw new Error(`Invalid action: ${transaction.action}`)
-  }
-
-  if (transaction.action === 'withdraw' && transaction.sourceStatus === 'pending') {
-    throw Error('Cannot build data for pending withdraw transaction');
-  }
-
-  if (!transaction.submitEvent) {
-    throw Error('Cannot build data for transaction without submitEvent');
-  }
-
-  const { to, amount, chainId, itoken: itokenAddress } = transaction.submitEvent;
-
-  const itoken = itokens[transaction.sourceChainId].find(token => token.address.toLowerCase() === itokenAddress.toLowerCase());
-
-  if (!itoken) {
-    throw Error('Cannot build data for transaction without itoken');
-  }
-
-  const token = tokens[chainId].find(t => t.symbol.toLowerCase() === itoken.symbol.toLowerCase());
-
-  if (!token) {
-    throw Error('Cannot build data for transaction without token');
-  }
-
-  const targetChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(transaction.targetChainId as ChainId));
-  const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
-  const gatewayAddress = addresses[chainId].interopXGateway;
-  const interopBridgeContract = getContract<InteropXGateway>(gatewayAddress, abi.interopXGateway, targetWallet);
-
-  const { data } = await interopBridgeContract.populateTransaction.systemWithdraw(
-    ethers.BigNumber.from(amount.toString()),
-    to,
-    token.address,
-    ethers.BigNumber.from(transaction.sourceChainId.toString()),
-    transaction.submitTransactionHash,
-  );
-
-  transactions.push({
-    to: gatewayAddress,
-    data: data!,
-    value: '0',
-    operation: OperationType.Call,
-  });
-
-  return encodeMulti(transactions).data
-}
-
-
-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 * 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';