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

package/src/typechain/factories/index.ts

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

package/src/typechain/index.ts

@@ -0,0 +1,12 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+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 { Erc20__factory } from "./factories/Erc20__factory";
+export { GnosisSafe__factory } from "./factories/GnosisSafe__factory";
+export { InstList__factory } from "./factories/InstList__factory";
+export { InteropX__factory } from "./factories/InteropX__factory";

package/src/types.ts

@@ -36,4 +36,4 @@ export type EventBusType = EventBus<Event.PEER_CONNECTED> &
   EventBus<Event.POOL_PEER_BANNED>
 
 
-export type ChainId = 1 | 137;
+export type ChainId = 1 | 137 | 43114;

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,30 @@
+import Web3EthAbi from "web3-eth-abi";
+import { connectors } from "@/abi/connectors";
+
+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;
+};

package/src/utils/formatting.ts

@@ -0,0 +1,15 @@
+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) + "...";
+}

package/src/utils/gnosis.ts

@@ -0,0 +1,123 @@
+import { addresses } from "@/constants";
+import { GnosisSafe } from "@/typechain";
+import { ChainId } from "@/types";
+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;
+};
+
+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 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 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;
+};

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,116 +1,8 @@
-/**
- * @module util
- */
-import axios from 'axios'
-import axiosRetry from "axios-retry";
-import { addresses } from '@/constants';
-import { ChainId } from '@/types'
-
-export const http = axios.create();
-
-axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
-
-
-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.instadapp.io/mainnet';
-    case 137:
-      return 'https://rpc.instadapp.io/polygon';
-    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 * from './async';
+export * from './dsa';
+export * from './formatting';
+export * from './gnosis';
+export * from './http';
+export * from './interop';
+export * from './web3';
+export * from './validate';

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

@@ -0,0 +1,24 @@
+import { addresses } from "@/constants";
+import { InvalidChaindIdError } from "@/errors";
+
+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");
+    }
+};

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;
+        },
+    });
+}

package/tsconfig.json

@@ -16,8 +16,13 @@
     "noEmit": false,
     "outDir": "dist",
     "baseUrl": "src",
-    "paths": { 
-      "@/*" : ["./*" ]
+    "paths": {
+      "@/*": [
+        "*"
+      ],
+      "@": [
+        "/"
+      ]
     },
     "typeRoots": [
       "./node_modules/@types",

package/dist/config/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const types_1 = require("@/types");
-class Config {
-    constructor() {
-        this.events = new types_1.EventBus();
-        this.maxPeers = 10;
-        this.privateKey = process.env.PRIVATE_KEY;
-        this.wallet = new ethers_1.Wallet(this.privateKey);
-        this.leadNodeAddress = '0x910E413DBF3F6276Fe8213fF656726bDc142E08E';
-    }
-    isLeadNode() {
-        return ethers_1.ethers.utils.getAddress(this.leadNodeAddress) === ethers_1.ethers.utils.getAddress(this.wallet.address);
-    }
-}
-exports.default = new Config();

package/dist/constants/addresses.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addresses = void 0;
-exports.addresses = {
-    1: {
-        gnosisSafe: '0x811Bff6eF88dAAA0aD6438386B534A81cE3F160F',
-        multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
-    },
-    137: {
-        gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
-        multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
-    },
-};

package/dist/db/models/execution.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Execution = void 0;
-const sequelize_1 = require("@/db/sequelize");
-const sequelize_2 = require("sequelize");
-class Execution extends sequelize_2.Model {
-}
-exports.Execution = Execution;
-Execution.init({
-    id: {
-        type: sequelize_2.DataTypes.INTEGER,
-        autoIncrement: true,
-        primaryKey: true
-    },
-    transactionHash: sequelize_2.DataTypes.STRING,
-    from: sequelize_2.DataTypes.STRING,
-    executions: sequelize_2.DataTypes.JSON,
-    chainId: sequelize_2.DataTypes.NUMBER,
-    gas: sequelize_2.DataTypes.STRING,
-    maxGasPrice: sequelize_2.DataTypes.STRING,
-    assets: sequelize_2.DataTypes.JSON,
-    metadata: sequelize_2.DataTypes.STRING,
-    vnonce: sequelize_2.DataTypes.STRING,
-    txHash: sequelize_2.DataTypes.STRING,
-    blockNumber: sequelize_2.DataTypes.STRING,
-    status: {
-        type: sequelize_2.DataTypes.STRING,
-        defaultValue: 'pending'
-    },
-    delayUntil: sequelize_2.DataTypes.DATE,
-    delayedCount: {
-        type: sequelize_2.DataTypes.INTEGER,
-        defaultValue: 0
-    },
-    error: sequelize_2.DataTypes.STRING,
-    createdAt: sequelize_2.DataTypes.DATE,
-    updatedAt: sequelize_2.DataTypes.DATE,
-}, { sequelize: sequelize_1.sequelize, tableName: 'executions' });

package/dist/index.js

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("module-alias/register");
-const assert_1 = __importDefault(require("assert"));
-const dotenv_1 = __importDefault(require("dotenv"));
-const logger_1 = __importDefault(require("@/logger"));
-const ethers_1 = require("ethers");
-dotenv_1.default.config();
-const logger = new logger_1.default('Process');
-(0, assert_1.default)(process.env.PRIVATE_KEY, "PRIVATE_KEY is not defined");
-try {
-    new ethers_1.ethers.Wallet(process.env.PRIVATE_KEY);
-}
-catch (e) {
-    logger.error('Invalid private key');
-    process.exit(1);
-}
-const tasks_1 = require("@/tasks");
-const net_1 = require("@/net");
-async function main() {
-    (0, net_1.startPeer)({});
-    const tasks = new tasks_1.Tasks();
-    tasks.start();
-}
-main()
-    .then(() => {
-}).catch(err => {
-    console.error(err);
-});
-process.on('SIGINT', () => {
-    logger.debug('received SIGINT signal. exiting.');
-    process.exit(0);
-});
-process.on('SIGTERM', () => {
-    logger.debug('received SIGTERM signal. exiting.');
-    process.exit(0);
-});
-process.on('unhandledRejection', (reason, p) => {
-    logger.error('unhandled rejection: promise:', p, 'reason:', reason);
-});