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

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@instadapp/interop-x",
-    "version": "0.0.0-dev.8f86e9f",
+    "version": "0.0.0-dev.9b1fcb8",
     "license": "MIT",
     "main": "dist/index.js",
     "engines": {

package/dist/src/constants/itokens.js

@@ -5,7 +5,7 @@ exports.itokens = {
     1: [],
     137: [
         {
-            address: '0x6c20F03598d5ABF729348E2868b0ff5e8A48aB1F',
+            address: '0xEab02fe1F016eE3e4106c1C6aad35FeEe657268E',
             symbol: 'USDC',
         }
     ],

package/dist/src/index.js

@@ -40,7 +40,7 @@ catch (e) {
     logger.error('Invalid private key');
     process.exit(1);
 }
-logger.debug(`Starting Interop X Node (v${package_json_1.default.version} - rev.8f86e9f)`);
+logger.debug(`Starting Interop X Node (v${package_json_1.default.version} - rev.9b1fcb8)`);
 const tasks_1 = require("@/tasks");
 const net_1 = require("@/net");
 const api_1 = require("@/api");

package/dist/src/net/protocol/dial/SignatureDialProtocol.js

@@ -33,8 +33,15 @@ class SignatureDialProtocol extends BaseDialProtocol_1.BaseDialProtocol {
                 error: 'Event not found'
             };
         }
+        console.log("signing:", {
+            to: constants_1.addresses[transaction.targetChainId].multisend,
+            data: await (0, utils_1.buildDataForTransaction)(transaction, data.type),
+            chainId: transaction.targetChainId,
+            safeTxGas: data.safeTxGas,
+            nonce: data.safeNonce,
+        });
         const signedData = await (0, utils_1.signGnosisSafeTx)({
-            to: constants_1.addresses[transaction.sourceChainId].multisend,
+            to: constants_1.addresses[transaction.targetChainId].multisend,
             data: await (0, utils_1.buildDataForTransaction)(transaction, data.type),
             chainId: transaction.targetChainId,
             safeTxGas: data.safeTxGas,

package/dist/src/tasks/InteropBridge/SyncWithdrawEvents.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseTask_1 = require("../BaseTask");
+const logger_1 = __importDefault(require("@/logger"));
+const ethers_1 = require("ethers");
+const abi_1 = __importDefault(require("@/abi"));
+const db_1 = require("@/db");
+const utils_1 = require("@/utils");
+const config_1 = __importDefault(require("@/config"));
+class SyncWithdrawEvents extends BaseTask_1.BaseTask {
+    constructor({ chainId, itokenAddress }) {
+        super({
+            logger: new logger_1.default("InteropBridgeToken::SyncWithdrawEvents"),
+        });
+        this.chainId = chainId;
+        this.itokenAddress = itokenAddress;
+    }
+    async pollHandler() {
+        const currentBlock = await this.provider.getBlockNumber();
+        const events = await this.contract.queryFilter(this.contract.filters.Burn(), currentBlock - 2000, currentBlock);
+        let processedEvents = 0;
+        for (const event of events) {
+            try {
+                if (!event.args) {
+                    continue;
+                }
+                const { to, amount, chainId } = event.args;
+                const uniqueIdentifier = {
+                    action: 'withdraw',
+                    submitTransactionHash: event.transactionHash,
+                    sourceChainId: this.chainId,
+                    targetChainId: chainId.toNumber(),
+                };
+                if (await db_1.Transaction.findOne({ where: uniqueIdentifier })) {
+                    continue;
+                }
+                const tx = await event.getTransaction();
+                await db_1.Transaction.create(Object.assign(Object.assign({}, uniqueIdentifier), { transactionHash: (0, utils_1.generateInteropTransactionHash)(uniqueIdentifier), from: tx.from, to, submitTransactionHash: event.transactionHash, submitBlockNumber: event.blockNumber, 
+                    // submit & source are the same
+                    sourceTransactionHash: event.transactionHash, sourceBlockNumber: event.blockNumber, sourceStatus: "success", targetStatus: "uninitialised", submitEvent: {
+                        to,
+                        amount: amount.toString(),
+                        chainId: chainId.toString()
+                    }, sourceEvent: {
+                        to,
+                        amount: amount.toString(),
+                        chainId: chainId.toString(),
+                    }, status: "pending" }));
+                this.logger.info(`Withdraw queued: ${event.transactionHash} ${event.blockNumber}`);
+            }
+            catch (error) {
+                this.logger.error(error);
+            }
+        }
+        if (processedEvents > 0)
+            this.logger.info(`${processedEvents} events processed`);
+    }
+    async start() {
+        this.logger.info(`Starting execution watcher on interop chain`);
+        this.provider = new ethers_1.ethers.providers.JsonRpcProvider((0, utils_1.getRpcProviderUrl)(this.chainId));
+        this.contract = (0, utils_1.getContract)(this.itokenAddress, abi_1.default.interopBridgeToken, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
+        await super.start();
+    }
+}
+exports.default = SyncWithdrawEvents;

package/dist/src/tasks/InteropXGateway/ProcessDepositEvents.js

@@ -58,6 +58,7 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
         if (!transaction) {
             return;
         }
+        console.log(`Processing transaction ${transaction.transactionHash}`);
         transaction.targetStatus = 'pending';
         await transaction.save();
         // refresh event data?
@@ -100,35 +101,17 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
             const errorMessage = (_a = signatures.find(s => !!s.error)) === null || _a === void 0 ? void 0 : _a.error;
             throw new Error(`Not enough signatures` + (errorMessage ? `: ${errorMessage}` : ''));
         }
-        const execTransactionParams = [
-            gnosisTx.to,
-            gnosisTx.value,
-            gnosisTx.data,
-            gnosisTx.operation,
-            gnosisTx.safeTxGas,
-            gnosisTx.baseGas,
-            gnosisTx.gasPrice,
-            gnosisTx.gasToken,
-            gnosisTx.refundReceiver,
-            (0, utils_1.buildSignatureBytes)(validSignatures),
-        ];
         console.log(`Executing transaction for execution ${transaction.transactionHash}`);
-        console.log({
-            execTransactionParams
-        });
         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, (0, utils_1.buildSignatureBytes)(validSignatures));
         console.log({
             from: targetWallet.address,
             gasPrice: ethers_1.BigNumber.from(120 * 10 ** 9).toString(),
-            gasLimit: ethers_1.BigNumber.from(6000000).toString(),
             to: safeAddress,
             data: txData,
         });
-        return;
         const txSent = await targetWallet.sendTransaction({
             from: targetWallet.address,
             gasPrice: ethers_1.BigNumber.from(120 * 10 ** 9),
-            gasLimit: ethers_1.BigNumber.from(6000000),
             to: safeAddress,
             data: txData,
         });
@@ -142,9 +125,15 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
         });
         if (parsedLogs.find(e => e.name === 'ExecutionSuccess')) {
             console.log('ExecutionSuccess');
+            transaction.targetStatus = 'success';
+            transaction.status = 'success';
+            await transaction.save();
         }
         else {
             console.log('ExecutionFailure');
+            transaction.targetStatus = 'failed';
+            transaction.status = 'failed';
+            await transaction.save();
         }
     }
     async start() {

package/dist/src/tasks/InteropXGateway/SyncDepositEvents.js

@@ -55,7 +55,7 @@ class SyncDepositEvents extends BaseTask_1.BaseTask {
                         amount: amount.toString(),
                         vnonce: vnonce.toString(),
                     }, status: "pending" }));
-                this.logger.info(`Execution queued: ${event.transactionHash} ${event.blockNumber}`);
+                this.logger.info(`Deposit queued: ${event.transactionHash} ${event.blockNumber}`);
             }
             catch (error) {
                 this.logger.error(error);

package/dist/src/tasks/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tasks = void 0;
 const ProcessDepositEvents_1 = __importDefault(require("./InteropXGateway/ProcessDepositEvents"));
 const SyncDepositEvents_1 = __importDefault(require("./InteropXGateway/SyncDepositEvents"));
+const SyncWithdrawEvents_1 = __importDefault(require("./InteropBridge/SyncWithdrawEvents"));
 class Tasks {
     constructor() {
         this.tasks = [
@@ -14,6 +15,10 @@ class Tasks {
             }),
             new ProcessDepositEvents_1.default({
                 chainId: 43114
+            }),
+            new SyncWithdrawEvents_1.default({
+                chainId: 137,
+                itokenAddress: '0xEab02fe1F016eE3e4106c1C6aad35FeEe657268E',
             })
         ];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instadapp/interop-x",
-  "version": "0.0.0-dev.8f86e9f",
+  "version": "0.0.0-dev.9b1fcb8",
   "license": "MIT",
   "main": "dist/index.js",
   "engines": {

package/src/constants/itokens.ts

@@ -2,7 +2,7 @@ export const itokens = {
   1: [],
   137: [
     {
-      address: '0x6c20F03598d5ABF729348E2868b0ff5e8A48aB1F',
+      address: '0xEab02fe1F016eE3e4106c1C6aad35FeEe657268E',
       symbol: 'USDC',
     }
   ],

package/src/net/protocol/dial/SignatureDialProtocol.ts

@@ -47,9 +47,17 @@ export class SignatureDialProtocol extends BaseDialProtocol<ISignatureRequest, I
             };
         }
 
+        console.log("signing:", {
+            to: addresses[transaction.targetChainId].multisend,
+            data: await buildDataForTransaction(transaction, data.type),
+            chainId: transaction.targetChainId as ChainId,
+            safeTxGas: data.safeTxGas,
+            nonce: data.safeNonce,
+        });
+
         const signedData = await signGnosisSafeTx({
-            to: addresses[transaction.sourceChainId].multisend,
-            data:  await buildDataForTransaction(transaction, data.type),
+            to: addresses[transaction.targetChainId].multisend,
+            data: await buildDataForTransaction(transaction, data.type),
             chainId: transaction.targetChainId as ChainId,
             safeTxGas: data.safeTxGas,
             nonce: data.safeNonce,

package/src/tasks/InteropBridge/SyncWithdrawEvents.ts

@@ -0,0 +1,119 @@
+import { BaseTask } from "../BaseTask";
+import Logger from '@/logger';
+import { ethers } from "ethers";
+import abi from "@/abi";
+import { Transaction } from "@/db";
+import { generateInteropTransactionHash, getContract, getRpcProviderUrl } from "@/utils";
+import { ChainId } from "@/types";
+import config from "@/config";
+import { InteropBridgeToken } from "@/typechain";
+
+class SyncWithdrawEvents extends BaseTask {
+    contractAddress: string;
+    provider: ethers.providers.JsonRpcProvider;
+    contract: InteropBridgeToken;
+    chainId: ChainId;
+    itokenAddress: string;
+
+    constructor({ chainId, itokenAddress }: { chainId: ChainId, itokenAddress: string }) {
+        super({
+            logger: new Logger("InteropBridgeToken::SyncWithdrawEvents"),
+        })
+        this.chainId = chainId;
+        this.itokenAddress = itokenAddress;
+    }
+
+    async pollHandler() {
+        const currentBlock = await this.provider.getBlockNumber();
+
+        const events = await this.contract.queryFilter(
+            this.contract.filters.Burn(),
+            currentBlock - 2000,
+            currentBlock,
+        );
+
+        let processedEvents = 0;
+
+        for (const event of events) {
+
+            try {
+                if (!event.args) {
+                    continue;
+                }
+
+                const { to, amount, chainId } = event.args;
+
+                const uniqueIdentifier = {
+                    action: 'withdraw',
+                    submitTransactionHash: event.transactionHash,
+                    sourceChainId:this.chainId,
+                    targetChainId: chainId.toNumber(),
+                }
+
+                if (await Transaction.findOne({ where: uniqueIdentifier })) {
+                    continue;
+                }
+
+                const tx = await event.getTransaction()
+
+                await Transaction.create({
+                    ...uniqueIdentifier,
+                    transactionHash: generateInteropTransactionHash(uniqueIdentifier),
+                    from: tx.from,
+                    to,
+
+                    
+                    submitTransactionHash: event.transactionHash,
+                    submitBlockNumber: event.blockNumber,
+
+                    // submit & source are the same
+                    sourceTransactionHash: event.transactionHash,
+                    sourceBlockNumber: event.blockNumber,
+                    sourceStatus: "success",
+
+                    targetStatus: "uninitialised",
+
+                    submitEvent: {
+                        to, 
+                        amount: amount.toString(), 
+                        chainId: chainId.toString()
+                    },
+
+                    sourceEvent: {
+                        to, 
+                        amount: amount.toString(), 
+                        chainId: chainId.toString(),
+                    },
+                    status: "pending",
+                })
+
+                this.logger.info(
+                    `Withdraw queued: ${event.transactionHash} ${event.blockNumber}`
+                );
+            } catch (error) {
+                this.logger.error(error);
+            }
+        }
+
+        if (processedEvents > 0)
+            this.logger.info(`${processedEvents} events processed`);
+    }
+
+    async start(): Promise<void> {
+        this.logger.info(`Starting execution watcher on interop chain`);
+
+        this.provider = new ethers.providers.JsonRpcProvider(
+            getRpcProviderUrl(this.chainId)
+        );
+
+        this.contract = getContract<InteropBridgeToken>(
+            this.itokenAddress,
+            abi.interopBridgeToken,
+            new ethers.Wallet(config.privateKey!, this.provider)
+        );
+
+        await super.start()
+    }
+}
+
+export default SyncWithdrawEvents;

package/src/tasks/InteropXGateway/ProcessDepositEvents.ts

@@ -96,11 +96,11 @@ class ProcessDepositEvents extends BaseTask {
             return;
         }
 
-
+        console.log(`Processing transaction ${transaction.transactionHash}`);
+        
         transaction.targetStatus = 'pending';
         await transaction.save();
 
-
         // refresh event data?
 
         const targetChainProvider = new ethers.providers.JsonRpcProvider(
@@ -165,25 +165,9 @@ class ProcessDepositEvents extends BaseTask {
             throw new Error(`Not enough signatures` + (errorMessage ? `: ${errorMessage}` : ''));
         }
 
-        const execTransactionParams = [
-            gnosisTx.to,
-            gnosisTx.value,
-            gnosisTx.data,
-            gnosisTx.operation,
-            gnosisTx.safeTxGas,
-            gnosisTx.baseGas,
-            gnosisTx.gasPrice,
-            gnosisTx.gasToken,
-            gnosisTx.refundReceiver,
-            buildSignatureBytes(validSignatures),
-        ];
 
         console.log(`Executing transaction for execution ${transaction.transactionHash}`)
 
-        console.log({
-            execTransactionParams
-        })
-
         const { data: txData } = await safeContract.populateTransaction.execTransaction(
             gnosisTx.to,
             gnosisTx.value,
@@ -200,16 +184,14 @@ class ProcessDepositEvents extends BaseTask {
         console.log({
             from: targetWallet.address,
             gasPrice: BigNumber.from(120 * 10 ** 9).toString(),
-            gasLimit: BigNumber.from(6_000_000).toString(),
             to: safeAddress,
             data: txData,
         })
-        return;
+
 
         const txSent = await targetWallet.sendTransaction({
             from: targetWallet.address,
             gasPrice: BigNumber.from(120 * 10 ** 9),
-            gasLimit: BigNumber.from(6_000_000),
             to: safeAddress,
             data: txData,
         })
@@ -226,8 +208,14 @@ class ProcessDepositEvents extends BaseTask {
 
         if (parsedLogs.find(e => e.name === 'ExecutionSuccess')) {
             console.log('ExecutionSuccess')
+            transaction.targetStatus = 'success'
+            transaction.status = 'success'
+            await transaction.save();
         } else {
             console.log('ExecutionFailure')
+            transaction.targetStatus = 'failed'
+            transaction.status = 'failed'
+            await transaction.save();
         }
     }
 

package/src/tasks/InteropXGateway/SyncDepositEvents.ts

@@ -93,7 +93,7 @@ class SyncDepositEvents extends BaseTask {
                 })
 
                 this.logger.info(
-                    `Execution queued: ${event.transactionHash} ${event.blockNumber}`
+                    `Deposit queued: ${event.transactionHash} ${event.blockNumber}`
                 );
             } catch (error) {
                 this.logger.error(error);

package/src/tasks/index.ts

@@ -1,6 +1,7 @@
 import { BaseTask } from "./BaseTask";
 import InteropXGatewayProcessDepositEvents from "./InteropXGateway/ProcessDepositEvents";
 import InteropXGatewaySyncDepositEvents from "./InteropXGateway/SyncDepositEvents";
+import InteropBridgeSyncWithdrawEvents from "./InteropBridge/SyncWithdrawEvents";
 
 export class Tasks {
     
@@ -11,6 +12,11 @@ export class Tasks {
 
         new InteropXGatewayProcessDepositEvents({
             chainId: 43114
+        }),
+
+        new InteropBridgeSyncWithdrawEvents({
+            chainId: 137,
+            itokenAddress: '0xEab02fe1F016eE3e4106c1C6aad35FeEe657268E',
         })
     ];