@instadapp/interop-x 0.0.0-dev.0159b4f

package/src/typechain/factories/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { Erc20__factory } from "./Erc20__factory";
+export { GnosisSafe__factory } from "./GnosisSafe__factory";
+export { InteropX__factory } from "./InteropX__factory";

package/src/typechain/index.ts

@@ -0,0 +1,10 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Erc20 } from "./Erc20";
+export type { GnosisSafe } from "./GnosisSafe";
+export type { InteropX } from "./InteropX";
+export * as factories from "./factories";
+export { Erc20__factory } from "./factories/Erc20__factory";
+export { GnosisSafe__factory } from "./factories/GnosisSafe__factory";
+export { InteropX__factory } from "./factories/InteropX__factory";

package/src/types.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'events'
+import { IPeerInfo } from '@/net'
+
+/**
+ * Types for the central event bus, emitted
+ * by different components of the client.
+ */
+export enum Event {
+  PEER_CONNECTED = 'peer:connected',
+  PEER_DISCONNECTED = 'peer:disconnected',
+  PEER_ERROR = 'peer:error',
+  POOL_PEER_ADDED = 'pool:peer:added',
+  POOL_PEER_REMOVED = 'pool:peer:removed',
+  POOL_PEER_BANNED = 'pool:peer:banned',
+}
+export interface EventParams {
+  [Event.PEER_CONNECTED]: [connectedPeer: IPeerInfo]
+  [Event.PEER_DISCONNECTED]: [disconnectedPeer: IPeerInfo]
+  [Event.PEER_ERROR]: [error: Error, peerCausingError: IPeerInfo]
+  [Event.POOL_PEER_ADDED]: [addedPeer: IPeerInfo]
+  [Event.POOL_PEER_REMOVED]: [removedPeer: IPeerInfo]
+  [Event.POOL_PEER_BANNED]: [bannedPeer: IPeerInfo]
+}
+
+export declare interface EventBus<T extends Event> {
+  emit(event: T, ...args: EventParams[T]): boolean
+  on(event: T, listener: (...args: EventParams[T]) => void): this
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class EventBus<T extends Event> extends EventEmitter { }
+export type EventBusType = EventBus<Event.PEER_CONNECTED> &
+  EventBus<Event.PEER_DISCONNECTED> &
+  EventBus<Event.POOL_PEER_ADDED> &
+  EventBus<Event.POOL_PEER_REMOVED> &
+  EventBus<Event.POOL_PEER_BANNED>
+
+
+export type ChainId = 1 | 137 | 43114;

package/src/utils/index.ts

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

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2017",
+    "noImplicitAny": false,
+    "noUnusedLocals": false,
+    "strictNullChecks": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "noEmit": false,
+    "outDir": "dist",
+    "baseUrl": "src",
+    "paths": {
+      "@/*": [
+        "*"
+      ],
+      "@": [
+        "/"
+      ]
+    },
+    "typeRoots": [
+      "./node_modules/@types",
+      "./@types"
+    ]
+  },
+  "include": [
+    "src/**/*",
+  ]
+}