@instadapp/interop-x 0.0.0-dev.ee3d74b → 0.0.0-dev.ef38dfb

package/src/utils/index.ts

@@ -1,365 +1,7 @@
-/**
- * @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";
-import retry from "async-retry";
-import { connectors } from "@/abi/connectors";
-
-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>;
-};
-
-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),
-    ]
-  );
-};
-
-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;
-    },
-  });
-}
-
-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 class LiquidityError extends Error {
-  constructor(message?: string) {
-    super(message || "Not enough liquidity");
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-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`);
-
-  const iface = new ethers.utils.Interface(connectorInterface);
-
-  return iface.encodeFunctionData(params.method, 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 * from './async';
+export * from './dsa';
+export * from './formatting';
+export * from './gnosis';
+export * from './http';
+export * from './interop';
+export * from './web3';

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/web3.ts

@@ -0,0 +1,131 @@
+import { ChainId } from "@/types";
+import retry from "async-retry";
+import { ethers } from "ethers";
+
+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 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;
+        },
+    });
+}