@instadapp/interop-x 0.0.0-dev.75809ae → 0.0.0-dev.79c1ae5

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 { InteropBridgeToken__factory } from "./InteropBridgeToken__factory";
+export { InteropXGateway__factory } from "./InteropXGateway__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 { InteropBridgeToken } from "./InteropBridgeToken";
+export type { InteropXGateway } from "./InteropXGateway";
+export * as factories from "./factories";
+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";

package/src/types.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events'
-import { IPeerInfo } from './net'
+import { IPeerInfo } from '@/net'
 
 /**
  * Types for the central event bus, emitted
@@ -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/index.ts

@@ -3,8 +3,14 @@
  */
 import axios from 'axios'
 import axiosRetry from "axios-retry";
-import { addresses } from '../constants';
-import { ChainId } from '../types'
+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();
 
@@ -73,6 +79,8 @@ export const getRpcProviderUrl = (chainId: ChainId) => {
       return 'https://rpc.instadapp.io/mainnet';
     case 137:
       return 'https://rpc.instadapp.io/polygon';
+    case 43114:
+      return 'https://rpc.instadapp.io/avalanche';
     default:
       throw new Error(`Unknown chainId: ${chainId}`);
   }
@@ -113,4 +121,187 @@ export const asyncCallWithTimeout = async <T>(asyncPromise: Promise<T>, timeout:
     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;
+    },
+  });
 }

package/tsconfig.json

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

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("../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,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const console_1 = require("console");
-const dotenv_1 = __importDefault(require("dotenv"));
-const tasks_1 = require("tasks");
-const logger_1 = __importDefault(require("./logger"));
-const net_1 = require("./net");
-dotenv_1.default.config();
-(0, console_1.assert)(process.env.PRIVATE_KEY, "PRIVATE_KEY is not defined");
-const logger = new logger_1.default('Process');
-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);
-});

package/dist/tasks/index.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tasks = void 0;
-class Tasks {
-    constructor() {
-        this.tasks = [];
-    }
-    async start() {
-        for (const task of this.tasks) {
-            try {
-                task.start();
-            }
-            catch (error) {
-                console.error(`Error starting task: ${task.constructor.name}`);
-            }
-        }
-    }
-}
-exports.Tasks = Tasks;

package/dist/utils/index.js

@@ -1,89 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncCallWithTimeout = exports.buildSignatureBytes = exports.getRpcProviderUrl = exports.signGnosisSafeTx = exports.short = exports.http = void 0;
-/**
- * @module util
- */
-const axios_1 = __importDefault(require("axios"));
-const axios_retry_1 = __importDefault(require("axios-retry"));
-const constants_1 = require("../constants");
-exports.http = axios_1.default.create();
-(0, axios_retry_1.default)(exports.http, { retries: 3, retryDelay: axios_retry_1.default.exponentialDelay });
-function short(buffer) {
-    return buffer.toString('hex').slice(0, 8) + '...';
-}
-exports.short = short;
-const signGnosisSafeTx = async ({ to, data = null, value = '0', operation = '1', baseGas = '0', gasPrice = "0", gasToken = "0x0000000000000000000000000000000000000000", refundReceiver = "0x0000000000000000000000000000000000000000", safeTxGas = "79668", nonce = "0", chainId = 137, }, { signer }) => {
-    const gnosisSafe = constants_1.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);
-};
-exports.signGnosisSafeTx = signGnosisSafeTx;
-const getRpcProviderUrl = (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}`);
-    }
-};
-exports.getRpcProviderUrl = getRpcProviderUrl;
-const buildSignatureBytes = (signatures) => {
-    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;
-};
-exports.buildSignatureBytes = buildSignatureBytes;
-/**
- * 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
- */
-const asyncCallWithTimeout = async (asyncPromise, timeout) => {
-    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;
-    });
-};
-exports.asyncCallWithTimeout = asyncCallWithTimeout;

package/src/db/models/execution.ts

@@ -1,57 +0,0 @@
-import { sequelize } from '../sequelize'
-import { CreationOptional, InferAttributes, InferCreationAttributes, Model, DataTypes } from 'sequelize';
-
-export class Execution extends Model<InferAttributes<Execution>, InferCreationAttributes<Execution>> {
-    declare id: CreationOptional<number>;
-
-    declare transactionHash: string;
-    declare from: string;
-    declare executions: any[];
-    declare chainId: number;
-    declare gas: string;
-    declare maxGasPrice: string;
-    declare assets: any[];
-    declare metadata: string;
-    declare vnonce: string;
-    declare txHash: string;
-
-    declare blockNumber: string;
-    declare status: CreationOptional<string>;
-    declare delayUntil: CreationOptional<Date>;
-    declare delayedCount: CreationOptional<number>;
-
-    declare error: CreationOptional<string>;
-    declare createdAt: CreationOptional<Date>;
-    declare updatedAt: CreationOptional<Date>;
-}
-
-Execution.init({
-    id: {
-        type: DataTypes.INTEGER,
-        autoIncrement: true,
-        primaryKey: true
-    },
-    transactionHash: DataTypes.STRING,
-    from: DataTypes.STRING,
-    executions: DataTypes.JSON,
-    chainId: DataTypes.NUMBER,
-    gas: DataTypes.STRING,
-    maxGasPrice: DataTypes.STRING,
-    assets: DataTypes.JSON,
-    metadata: DataTypes.STRING,
-    vnonce: DataTypes.STRING,
-    txHash: DataTypes.STRING,
-    blockNumber: DataTypes.STRING,
-    status: {
-        type: DataTypes.STRING,
-        defaultValue: 'pending'
-    },
-    delayUntil: DataTypes.DATE,
-    delayedCount: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0
-    },
-    error: DataTypes.STRING,
-    createdAt: DataTypes.DATE,
-    updatedAt: DataTypes.DATE,
-}, { sequelize, tableName: 'executions' });