@instadapp/interop-x 0.0.0-dev.59f2858 → 0.0.0-dev.62ea999

package/src/tasks/InteropXGateway/ProcessDepositEvents.ts

@@ -0,0 +1,245 @@
+import { BaseTask } from "../BaseTask";
+import Logger from '@/logger';
+import { BigNumber, ethers } from "ethers";
+import abi from "@/abi";
+import { Transaction } from "@/db";
+import { buildDataForTransaction, buildSignatureBytes, getContract, getRpcProviderUrl, Signature } from "@/utils";
+import { addresses } from "@/constants";
+import { ChainId } from "@/types";
+import config from "@/config";
+import { GnosisSafe, InteropXGateway } from "@/typechain";
+import { Op } from "sequelize";
+import wait from "waait";
+import { peerPool, protocol } from "@/net";
+import { LogDescription } from "ethers/lib/utils";
+
+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 = 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
+}
+
+class ProcessDepositEvents extends BaseTask {
+    contractAddress: string;
+    provider: ethers.providers.JsonRpcProvider;
+    contract: InteropXGateway;
+    chainId: ChainId;
+    leadNodeOnly = true
+
+    constructor({ chainId }: { chainId: ChainId }) {
+        super({
+            logger: new Logger("InteropXGateway::ProcessDepositEvents"),
+        })
+        this.chainId = chainId;
+    }
+
+    async pollHandler() {
+        const blockNumber = await this.provider.getBlockNumber()
+
+        const transaction = await Transaction.findOne({
+            where: {
+                status: 'pending',
+                sourceStatus: 'success',
+                targetStatus: 'uninitialised',
+                action: 'deposit',
+                sourceCreatedAt: {
+                    [Op.gte]: new Date(Date.now() - 12 * 60 * 60 * 1000),
+                },
+                targetDelayUntil: {
+                    [Op.or]: {
+                        [Op.is]: null,
+                        [Op.lt]: new Date(),
+                    }
+                },
+                sourceBlockNumber: {
+                    [Op.lt]: blockNumber - 12,
+                },
+                sourceChainId: this.chainId,
+            }
+        })
+
+        if (!transaction) {
+            return;
+        }
+
+        console.log(`Processing transaction ${transaction.transactionHash}`);
+        
+        transaction.targetStatus = 'pending';
+        await transaction.save();
+
+        // refresh event data?
+
+        const targetChainProvider = new ethers.providers.JsonRpcProvider(
+            getRpcProviderUrl(transaction.targetChainId as ChainId)
+        );
+
+        const targetWallet = new ethers.Wallet(config.privateKey!, targetChainProvider);
+
+        const safeAddress = addresses[transaction.targetChainId].gnosisSafe;
+
+
+        const safeContract = getContract<GnosisSafe>(
+            safeAddress,
+            abi.gnosisSafe,
+            targetWallet
+        )
+
+        const ownersThreshold = await safeContract.getThreshold();
+        await wait(10000);
+
+        let gnosisTx = await generateGnosisTransaction({
+            baseGas: "0",
+            data: await buildDataForTransaction(transaction),
+            gasPrice: "0",
+            gasToken: "0x0000000000000000000000000000000000000000",
+            nonce: '0',
+            operation: "1",
+            refundReceiver: "0x0000000000000000000000000000000000000000",
+            safeAddress: safeAddress,
+            safeTxGas: "79668",
+            to: addresses[transaction.targetChainId].multisend,
+            value: "0",
+        }, safeContract);
+
+        const owners = await safeContract.getOwners().then(owners => owners.map(owner => owner.toLowerCase()));
+
+        const ownerPeerIds = peerPool.activePeers.filter(peer => owners.includes(peer.publicAddress.toLowerCase())).map(peer => peer.id)
+
+        console.log(`Collecting signatures for execution ${transaction.transactionHash}`)
+
+        console.log(ownerPeerIds);
+        
+        const signatures = await protocol.requestSignatures({
+            type: 'source',
+            transactionHash: transaction.transactionHash,
+            safeTxGas: gnosisTx.safeTxGas,
+            safeNonce: gnosisTx.nonce
+        }, ownerPeerIds)
+
+
+        const validSignatures = signatures.filter(s => !!s.data && s.data !== '0x') as Signature[];
+
+        console.log({ signatures, validSignatures, ownersThreshold: ownersThreshold.toString() });
+
+        if (validSignatures.length === 0 || ownersThreshold.gt(validSignatures.length)) {
+            await transaction.save();
+            transaction.targetDelayUntil = new Date(Date.now() + 30 * 1000);
+            transaction.targetStatus = 'uninitialised'
+
+            await transaction.save();
+            const errorMessage = signatures.find(s => !!s.error)?.error;
+            throw new Error(`Not enough signatures` + (errorMessage ? `: ${errorMessage}` : ''));
+        }
+
+
+        console.log(`Executing transaction for execution ${transaction.transactionHash}`)
+
+        const { data: txData } = await safeContract.populateTransaction.execTransaction(
+            gnosisTx.to,
+            gnosisTx.value,
+            gnosisTx.data,
+            gnosisTx.operation,
+            gnosisTx.safeTxGas,
+            gnosisTx.baseGas,
+            gnosisTx.gasPrice,
+            gnosisTx.gasToken,
+            gnosisTx.refundReceiver,
+            buildSignatureBytes(validSignatures)
+        );
+
+        console.log({
+            from: targetWallet.address,
+            gasPrice: BigNumber.from(120 * 10 ** 9).toString(),
+            to: safeAddress,
+            data: txData,
+        })
+
+
+        const txSent = await targetWallet.sendTransaction({
+            from: targetWallet.address,
+            gasPrice: BigNumber.from(120 * 10 ** 9),
+            to: safeAddress,
+            data: txData,
+        })
+
+        const receipt = await txSent.wait();
+
+        const parsedLogs: LogDescription[] = [];
+
+        receipt.logs.forEach((log) => {
+            try {
+                parsedLogs.push(safeContract.interface.parseLog(log));
+            } catch (e) { }
+        });
+
+        if (parsedLogs.find(e => e.name === 'ExecutionSuccess')) {
+            console.log('ExecutionSuccess')
+            transaction.targetStatus = 'success'
+            transaction.targetTransactionHash = txSent.hash
+            transaction.status = 'success'
+            await transaction.save();
+        } else {
+            console.log('ExecutionFailure')
+            transaction.targetStatus = 'failed'
+            transaction.targetTransactionHash = txSent.hash
+            transaction.status = 'failed'
+            await transaction.save();
+        }
+
+        protocol.sendTransaction(transaction)
+    }
+
+    async start(): Promise<void> {
+        this.logger.info(`Starting execution watcher on interop chain`);
+
+        this.contractAddress = addresses[this.chainId].interopXGateway;
+
+        this.provider = new ethers.providers.JsonRpcProvider(
+            getRpcProviderUrl(this.chainId)
+        );
+
+        this.contract = getContract<InteropXGateway>(
+            this.contractAddress,
+            abi.interopXGateway,
+            new ethers.Wallet(config.privateKey!, this.provider)
+        );
+
+        await super.start()
+    }
+}
+
+export default ProcessDepositEvents;

package/src/tasks/InteropXGateway/SyncDepositEvents.ts

@@ -3,7 +3,7 @@ import Logger from '@/logger';
 import { ethers } from "ethers";
 import abi from "@/abi";
 import { Transaction } from "@/db";
-import { generateInteropTransactionHash, getRpcProviderUrl } from "@/utils";
+import { generateInteropTransactionHash, getContract, getRpcProviderUrl } from "@/utils";
 import { addresses } from "@/constants";
 import { ChainId } from "@/types";
 import config from "@/config";
@@ -44,7 +44,7 @@ class SyncDepositEvents extends BaseTask {
 
                 const uniqueIdentifier = {
                     action: 'deposit',
-                    sourceTransactionHash: event.transactionHash,
+                    submitTransactionHash: event.transactionHash,
                     sourceChainId: sourceChainId.toNumber(),
                     targetChainId: targetChainId.toNumber(),
                 }
@@ -61,8 +61,14 @@ class SyncDepositEvents extends BaseTask {
                     from: tx.from,
                     to: user,
 
+                    
+                    submitTransactionHash: event.transactionHash,
+                    submitBlockNumber: event.blockNumber,
+
+                    // submit & source are the same
+                    sourceTransactionHash: event.transactionHash,
                     sourceBlockNumber: event.blockNumber,
-                    sourceStatus: "uninitialised",
+                    sourceStatus: "success",
 
                     targetStatus: "uninitialised",
 
@@ -71,14 +77,23 @@ class SyncDepositEvents extends BaseTask {
                         sourceChainId: sourceChainId.toString(),
                         targetChainId: targetChainId.toString(),
                         token: token,
-                        ammout: amount.toString(),
+                        amount: amount.toString(),
+                        vnonce: vnonce.toString(),
+                    },
+
+                    sourceEvent: {
+                        user,
+                        sourceChainId: sourceChainId.toString(),
+                        targetChainId: targetChainId.toString(),
+                        token: token,
+                        amount: amount.toString(),
                         vnonce: vnonce.toString(),
                     },
                     status: "pending",
                 })
 
                 this.logger.info(
-                    `Execution queued: ${event.transactionHash} ${event.blockNumber}`
+                    `Deposit queued: ${event.transactionHash} ${event.blockNumber}`
                 );
             } catch (error) {
                 this.logger.error(error);
@@ -98,11 +113,11 @@ class SyncDepositEvents extends BaseTask {
             getRpcProviderUrl(this.chainId)
         );
 
-        this.contract = new ethers.Contract(
+        this.contract = getContract<InteropXGateway>(
             this.contractAddress,
             abi.interopXGateway,
             new ethers.Wallet(config.privateKey!, this.provider)
-        ) as InteropXGateway;
+        );
 
         await super.start()
     }

package/src/tasks/index.ts

@@ -1,11 +1,28 @@
 import { BaseTask } from "./BaseTask";
-import SyncInteropXGatewayDepositEvents from "./InteropXGateway/SyncDepositEvents";
+import InteropXGatewayProcessDepositEvents from "./InteropXGateway/ProcessDepositEvents";
+import InteropXGatewaySyncDepositEvents from "./InteropXGateway/SyncDepositEvents";
+
+import InteropBridgeSyncWithdrawEvents from "./InteropBridge/SyncWithdrawEvents";
+import InteropBridgeProcessWithdrawEvents from "./InteropBridge/ProcessWithdrawEvents";
 
 export class Tasks {
     
     tasks: BaseTask[] = [
-        new SyncInteropXGatewayDepositEvents({
+        new InteropXGatewaySyncDepositEvents({
+            chainId: 43114
+        }),
+
+        new InteropXGatewayProcessDepositEvents({
             chainId: 43114
+        }),
+
+        new InteropBridgeSyncWithdrawEvents({
+            chainId: 137,
+            itokenAddress: '0xEab02fe1F016eE3e4106c1C6aad35FeEe657268E',
+        }),
+
+        new InteropBridgeProcessWithdrawEvents({
+            chainId: 137,
         })
     ];
 

package/src/utils/index.ts

@@ -3,9 +3,14 @@
  */
 import axios from 'axios'
 import axiosRetry from "axios-retry";
-import { addresses } from '@/constants';
+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();
 
@@ -119,11 +124,178 @@ export const asyncCallWithTimeout = async <T>(asyncPromise: Promise<T>, timeout:
 }
 
 
-export const generateInteropTransactionHash = (data: { action: string, sourceTransactionHash: string, sourceChainId: string | number, targetChainId: string | number }) => {
+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.sourceTransactionHash),
+    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
+
+
+  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/dist/utils/index.js

@@ -1,101 +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.generateInteropTransactionHash = 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");
-const ethers_1 = require("ethers");
-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';
-        case 43114:
-            return 'https://rpc.instadapp.io/avalanche';
-        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;
-const generateInteropTransactionHash = (data) => {
-    return ethers_1.ethers.utils.solidityKeccak256(['string', 'string', 'string', 'string'], [
-        String(data.action),
-        String(data.sourceTransactionHash),
-        String(data.sourceChainId),
-        String(data.targetChainId),
-    ]);
-};
-exports.generateInteropTransactionHash = generateInteropTransactionHash;