@instadapp/interop-x 0.0.0-dev.9b1fcb8 → 0.0.0-dev.a846f65

package/src/tasks/AutoUpdateTask.ts

@@ -0,0 +1,81 @@
+import { BaseTask } from "./BaseTask";
+import Logger from '@/logger';
+import { http } from "@/utils";
+import spawn from 'await-spawn';
+import config from "@/config";
+import wait from "waait";
+import packageJson from "../../package.json";
+
+const currentVersion = packageJson.version;
+
+class AutoUpdateTask extends BaseTask {
+    pollIntervalMs: number = 60 * 5 * 1000
+
+    constructor() {
+        super({
+            logger: new Logger("AutoUpdateTask"),
+        })
+    }
+
+    prePollHandler(): boolean {
+        return config.autoUpdate && !config.isLeadNode();
+    }
+
+    async getInstalledVersion() {
+        try {
+            const stdout = await spawn('npm', ['-g', 'ls', '--depth=0', '--json'])
+            return JSON.parse(stdout.toString()).dependencies[packageJson.name].version
+        } catch (error) {
+            this.logger.error(error)
+            
+            return currentVersion
+        }
+    }
+
+    async getLatestVersion() {
+        try {
+            const stdout = await spawn('npm', ['view', packageJson.name, 'version'])
+            return stdout.toString()
+        } catch (error) {
+            this.logger.error(error)
+            
+            return currentVersion
+        }
+    }
+
+    async pollHandler() {
+        const version = await this.getLatestVersion()
+
+        if (version === currentVersion) {
+            return;
+        }
+
+        this.logger.warn(`New version ${version} available.`)
+
+
+        this.logger.info('Updating...')
+
+        const spawner = spawn('npm', ['-g', 'install', '@instadapp/interop-x@latest']);
+        spawner.child.on('data', console.log)
+        await spawner
+
+        await wait(5000)
+
+        if (version !== await this.getInstalledVersion()) {
+            this.logger.warn(`failed to install ${version}, retrying in 5 minutes`)
+            return;
+        }
+
+        this.logger.warn(`Installed version ${version}`)
+        this.logger.warn(`Restarting...`)
+
+        spawn(process.argv[0], process.argv.slice(1), {
+            cwd: process.cwd(),
+            stdio: "inherit"
+        });
+
+        process.exit()
+    }
+}
+
+export default AutoUpdateTask;

package/src/tasks/BaseTask.ts

@@ -19,6 +19,7 @@ export class BaseTask extends EventEmitter implements IBaseTask {
     started: boolean = false
     pollIntervalMs: number = 10 * 1000
     leadNodeOnly: boolean = false
+    exceptLeadNode: boolean = false
 
     public constructor({ logger }: { logger?: Logger }) {
         super()
@@ -45,11 +46,15 @@ export class BaseTask extends EventEmitter implements IBaseTask {
     }
 
     prePollHandler(): boolean {
-        if (!this.leadNodeOnly) {
-            return true
+        if (this.exceptLeadNode) {
+            return !config.isLeadNode();
         }
 
-        return config.isLeadNode()
+        if (this.leadNodeOnly) {
+            return config.isLeadNode()
+        }
+
+        return true
     }
 
     async pollHandler() {

package/src/tasks/InteropBridge/ProcessWithdrawEvents.ts

@@ -0,0 +1,231 @@
+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 ProcessWithdrawEvents extends BaseTask {
+    provider: ethers.providers.JsonRpcProvider;
+    chainId: ChainId;
+    leadNodeOnly = true
+
+    constructor({ chainId }: { chainId: ChainId }) {
+        super({
+            logger: new Logger("InteropXGateway::ProcessWithdrawEvents"),
+        })
+        this.chainId = chainId;
+    }
+
+    async pollHandler() {
+        const blockNumber = await this.provider.getBlockNumber()
+
+        const transaction = await Transaction.findOne({
+            where: {
+                status: 'pending',
+                sourceStatus: 'success',
+                targetStatus: 'uninitialised',
+                action: 'withdraw',
+                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();
+        }
+    }
+
+    async start(): Promise<void> {
+        this.provider = new ethers.providers.JsonRpcProvider(
+            getRpcProviderUrl(this.chainId)
+        );
+
+        await super.start()
+    }
+}
+
+export default ProcessWithdrawEvents;

package/src/tasks/InteropBridge/SyncWithdrawEvents.ts

@@ -75,13 +75,15 @@ class SyncWithdrawEvents extends BaseTask {
 
                     submitEvent: {
                         to, 
-                        amount: amount.toString(), 
+                        amount: amount.toString(),
+                        itoken: this.itokenAddress,
                         chainId: chainId.toString()
                     },
 
                     sourceEvent: {
                         to, 
                         amount: amount.toString(), 
+                        itoken: this.itokenAddress,
                         chainId: chainId.toString(),
                     },
                     status: "pending",
@@ -100,8 +102,6 @@ class SyncWithdrawEvents extends BaseTask {
     }
 
     async start(): Promise<void> {
-        this.logger.info(`Starting execution watcher on interop chain`);
-
         this.provider = new ethers.providers.JsonRpcProvider(
             getRpcProviderUrl(this.chainId)
         );

package/src/tasks/InteropXGateway/ProcessDepositEvents.ts

@@ -209,19 +209,21 @@ class ProcessDepositEvents extends BaseTask {
         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(

package/src/tasks/InteropXGateway/SyncDepositEvents.ts

@@ -105,8 +105,6 @@ class SyncDepositEvents extends BaseTask {
     }
 
     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(

package/src/tasks/Transactions/SyncTransactionStatusTask.ts

@@ -0,0 +1,65 @@
+import { BaseTask } from "../BaseTask";
+import Logger from '@/logger';
+import config from "@/config";
+import { peerPool, protocol } from "@/net";
+import { Transaction } from "@/db";
+import { Op } from "sequelize";
+
+class SyncTransactionStatusTask extends BaseTask {
+    pollIntervalMs: number = 60 * 1000
+    exceptLeadNode: boolean = true;
+
+    constructor() {
+        super({
+            logger: new Logger("SyncTransactionStatusTask"),
+        })
+    }
+    
+    async pollHandler() {
+        // if transaction is pending for more than 1 hour, check lead node for status
+        const leadNode = peerPool.getLeadPeer();
+
+        if (!leadNode) {
+            return;
+        }
+
+        const transaction = await Transaction.findOne({
+            where: {
+                status: 'pending',
+                sourceCreatedAt: {
+                    [Op.gte]: new Date(Date.now() - 60 * 60 * 1000),
+                },
+            }
+        })
+
+        if (!transaction) {
+            return;
+        }
+
+        this.logger.info(`Requesting transaction status for ${transaction.transactionHash}`)
+
+        const transactionStatus = await protocol.requestTransactionStatus(transaction.transactionHash, leadNode.id);
+
+        if (!transactionStatus) {
+            return;
+        }
+
+        this.logger.info(`Received transaction status for ${transaction.transactionHash}`)
+
+        transaction.sourceStatus = transactionStatus.sourceStatus
+        transaction.sourceTransactionHash = transactionStatus.sourceTransactionHash
+        transaction.sourceErrors = transactionStatus.sourceErrors
+
+        transaction.targetStatus = transactionStatus.targetStatus
+        transaction.targetTransactionHash = transactionStatus.targetTransactionHash
+        transaction.targetErrors = transactionStatus.targetErrors
+
+        transaction.status = transactionStatus.status
+
+        await transaction.save()
+
+        this.logger.info(`Updated transaction status for ${transaction.transactionHash}`)
+    }
+}
+
+export default SyncTransactionStatusTask;

package/src/tasks/index.ts

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

package/src/utils/index.ts

@@ -10,13 +10,25 @@ import { encodeMulti, MetaTransaction, OperationType } from 'ethers-multisend';
 import { Transaction } from '@/db';
 import config from '@/config';
 import abi from '@/abi';
-import { InteropBridgeToken } from '@/typechain';
+import { InteropBridgeToken, InteropXGateway } from '@/typechain';
 
 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) + '...'
 }
@@ -76,11 +88,11 @@ export const signGnosisSafeTx = async ({
 export const getRpcProviderUrl = (chainId: ChainId) => {
   switch (chainId) {
     case 1:
-      return 'https://rpc.instadapp.io/mainnet';
+      return 'https://rpc.ankr.com/eth';
     case 137:
-      return 'https://rpc.instadapp.io/polygon';
+      return 'https://rpc.ankr.com/polygon';
     case 43114:
-      return 'https://rpc.instadapp.io/avalanche';
+      return 'https://rpc.ankr.com/avalanche';
     default:
       throw new Error(`Unknown chainId: ${chainId}`);
   }
@@ -136,10 +148,21 @@ export const generateInteropTransactionHash = (data: { action: string, submitTra
 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');
+  if (transaction.action !== 'deposit') {
+    throw new Error(`Invalid action: ${transaction.action}`)
   }
 
   if (transaction.action === 'deposit' && transaction.sourceStatus === 'pending') {
@@ -171,7 +194,7 @@ export const buildDataForTransaction = async (transaction: Transaction, type?: '
     transaction.submitEvent.user,
     ethers.BigNumber.from(transaction.submitEvent.amount.toString()),
     ethers.BigNumber.from(transaction.submitEvent.sourceChainId.toString()),
-    transaction.sourceTransactionHash,
+    transaction.submitTransactionHash,
   );
 
   transactions.push({
@@ -184,6 +207,58 @@ export const buildDataForTransaction = async (transaction: Transaction, type?: '
   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) {
@@ -196,6 +271,12 @@ export function getContract<TContract extends ethers.Contract>(address: string,
     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) {