@instadapp/interop-x 0.0.0-dev.7a02577 → 0.0.0-dev.7adf1b5

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

@@ -14,7 +14,9 @@ const config_1 = __importDefault(require("@/config"));
 const sequelize_1 = require("sequelize");
 const waait_1 = __importDefault(require("waait"));
 const net_1 = require("@/net");
+const gnosis_1 = require("@/gnosis");
 const generateGnosisTransaction = async (transactionData, safeContract) => {
+    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_1.BigNumber.from(String(transactionData.safeTxGas)).add(1).toString();
@@ -37,30 +39,52 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
             where: {
                 status: 'pending',
                 sourceStatus: 'success',
+                targetStatus: 'uninitialised',
                 action: 'deposit',
                 sourceCreatedAt: {
                     [sequelize_1.Op.gte]: new Date(Date.now() - 12 * 60 * 60 * 1000),
                 },
+                targetDelayUntil: {
+                    [sequelize_1.Op.or]: {
+                        [sequelize_1.Op.is]: null,
+                        [sequelize_1.Op.lt]: new Date(),
+                    }
+                },
                 sourceBlockNumber: {
                     [sequelize_1.Op.lt]: blockNumber - 12,
-                }
+                },
+                sourceChainId: this.chainId,
             }
         });
         if (!transaction) {
             return;
         }
-        transaction.sourceStatus = 'pending';
+        console.log(`Processing transaction ${transaction.transactionHash}`);
+        transaction.targetStatus = 'pending';
         await transaction.save();
         // refresh event data?
         const targetChainProvider = new ethers_1.ethers.providers.JsonRpcProvider((0, utils_1.getRpcProviderUrl)(transaction.targetChainId));
         const targetWallet = new ethers_1.ethers.Wallet(config_1.default.privateKey, targetChainProvider);
         const safeAddress = constants_1.addresses[transaction.targetChainId].gnosisSafe;
-        const safeContract = new ethers_1.ethers.Contract(safeAddress, abi_1.default.gnosisSafe, targetWallet);
+        const safeContract = (0, utils_1.getContract)(safeAddress, abi_1.default.gnosisSafe, targetWallet);
         const ownersThreshold = await safeContract.getThreshold();
         await (0, waait_1.default)(10000);
+        let data, logs = [];
+        try {
+            ({ data, logs } = await (0, gnosis_1.buildGnosisAction)(transaction));
+        }
+        catch (error) {
+            console.log(error);
+            transaction.targetStatus = 'failed';
+            transaction.targetErrors = [error.message];
+            transaction.status = 'failed';
+            await transaction.save();
+            net_1.protocol.sendTransaction(transaction);
+            return;
+        }
         let gnosisTx = await generateGnosisTransaction({
             baseGas: "0",
-            data: (0, utils_1.buildDataForTransaction)(transaction),
+            data,
             gasPrice: "0",
             gasToken: "0x0000000000000000000000000000000000000000",
             nonce: '0',
@@ -74,6 +98,7 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
         const owners = await safeContract.getOwners().then(owners => owners.map(owner => owner.toLowerCase()));
         const ownerPeerIds = net_1.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 net_1.protocol.requestSignatures({
             type: 'source',
             transactionHash: transaction.transactionHash,
@@ -84,33 +109,23 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
         console.log({ signatures, validSignatures, ownersThreshold: ownersThreshold.toString() });
         if (validSignatures.length === 0 || ownersThreshold.gt(validSignatures.length)) {
             await transaction.save();
-            transaction.sourceDelayUntil = new Date(Date.now() + 30 * 1000);
-            transaction.sourceStatus = 'pending';
+            transaction.targetDelayUntil = new Date(Date.now() + 30 * 1000);
+            transaction.targetStatus = 'uninitialised';
             await transaction.save();
             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}`);
+        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({
-            execTransactionParams
+            from: targetWallet.address,
+            gasPrice: ethers_1.BigNumber.from(120 * 10 ** 9).toString(),
+            to: safeAddress,
+            data: txData,
         });
-        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));
         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,
         });
@@ -124,16 +139,25 @@ class ProcessDepositEvents extends BaseTask_1.BaseTask {
         });
         if (parsedLogs.find(e => e.name === 'ExecutionSuccess')) {
             console.log('ExecutionSuccess');
+            transaction.targetStatus = 'success';
+            transaction.targetTransactionHash = txSent.hash;
+            transaction.targetLogs = logs;
+            transaction.status = 'success';
+            await transaction.save();
         }
         else {
             console.log('ExecutionFailure');
+            transaction.targetStatus = 'failed';
+            transaction.targetTransactionHash = txSent.hash;
+            transaction.status = 'failed';
+            await transaction.save();
         }
+        net_1.protocol.sendTransaction(transaction);
     }
     async start() {
-        this.logger.info(`Starting execution watcher on interop chain`);
         this.contractAddress = constants_1.addresses[this.chainId].interopXGateway;
         this.provider = new ethers_1.ethers.providers.JsonRpcProvider((0, utils_1.getRpcProviderUrl)(this.chainId));
-        this.contract = new ethers_1.ethers.Contract(this.contractAddress, abi_1.default.interopXGateway, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
+        this.contract = (0, utils_1.getContract)(this.contractAddress, abi_1.default.interopXGateway, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
         await super.start();
     }
 }

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

@@ -31,8 +31,8 @@ class SyncDepositEvents extends BaseTask_1.BaseTask {
                 const uniqueIdentifier = {
                     action: 'deposit',
                     submitTransactionHash: event.transactionHash,
-                    sourceChainId: sourceChainId.toNumber(),
-                    targetChainId: targetChainId.toNumber(),
+                    sourceChainId: sourceChainId,
+                    targetChainId: targetChainId,
                 };
                 if (await db_1.Transaction.findOne({ where: uniqueIdentifier })) {
                     continue;
@@ -45,17 +45,17 @@ class SyncDepositEvents extends BaseTask_1.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,
-                        ammout: amount.toString(),
+                        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);
@@ -65,10 +65,9 @@ class SyncDepositEvents extends BaseTask_1.BaseTask {
             this.logger.info(`${processedEvents} events processed`);
     }
     async start() {
-        this.logger.info(`Starting execution watcher on interop chain`);
         this.contractAddress = constants_1.addresses[this.chainId].interopXGateway;
         this.provider = new ethers_1.ethers.providers.JsonRpcProvider((0, utils_1.getRpcProviderUrl)(this.chainId));
-        this.contract = new ethers_1.ethers.Contract(this.contractAddress, abi_1.default.interopXGateway, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
+        this.contract = (0, utils_1.getContract)(this.contractAddress, abi_1.default.interopXGateway, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
         await super.start();
     }
 }

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

@@ -0,0 +1,72 @@
+"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 constants_1 = require("@/constants");
+const config_1 = __importDefault(require("@/config"));
+class SyncWithdrawEvents extends BaseTask_1.BaseTask {
+    constructor({ chainId }) {
+        super({
+            logger: new logger_1.default("InteropXGateway::SyncWithdrawEvents"),
+        });
+        this.chainId = chainId;
+    }
+    async pollHandler() {
+        const currentBlock = await this.provider.getBlockNumber();
+        const events = await this.contract.queryFilter(this.contract.filters.LogGatewayWithdraw(), currentBlock - 500, currentBlock);
+        let processedEvents = 0;
+        for (const event of events) {
+            try {
+                if (!event.args) {
+                    continue;
+                }
+                const { user, token, amount, sourceChainId, targetChainId, transactionHash } = event.args;
+                const uniqueIdentifier = {
+                    action: 'withdraw',
+                    submitTransactionHash: transactionHash,
+                    sourceChainId: sourceChainId,
+                    targetChainId: targetChainId,
+                    targetEvent: null
+                };
+                const transaction = await db_1.Transaction.findOne({ where: uniqueIdentifier });
+                if (!transaction) {
+                    return;
+                }
+                const tx = await event.getTransaction();
+                transaction.targetStatus = 'success';
+                transaction.targetErrors = [];
+                transaction.targetTransactionHash = tx.hash;
+                transaction.targetEvent = {
+                    user,
+                    token,
+                    amount: amount.toString(),
+                    sourceChainId,
+                    targetChainId,
+                    transactionHash,
+                };
+                transaction.status = 'success';
+                await transaction.save();
+                this.logger.info(`Witdraw confirmation received: ${transaction.transactionHash} `);
+            }
+            catch (error) {
+                this.logger.error(error);
+            }
+        }
+        if (processedEvents > 0)
+            this.logger.info(`${processedEvents} events processed`);
+    }
+    async start() {
+        this.contractAddress = constants_1.addresses[this.chainId].interopXGateway;
+        this.provider = new ethers_1.ethers.providers.JsonRpcProvider((0, utils_1.getRpcProviderUrl)(this.chainId));
+        this.contract = (0, utils_1.getContract)(this.contractAddress, abi_1.default.interopXGateway, new ethers_1.ethers.Wallet(config_1.default.privateKey, this.provider));
+        await super.start();
+    }
+}
+exports.default = SyncWithdrawEvents;

package/dist/src/tasks/Transactions/SyncTransactionStatusTask.js

@@ -0,0 +1,53 @@
+"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 net_1 = require("@/net");
+const db_1 = require("@/db");
+const sequelize_1 = require("sequelize");
+class SyncTransactionStatusTask extends BaseTask_1.BaseTask {
+    constructor() {
+        super({
+            logger: new logger_1.default("SyncTransactionStatusTask"),
+        });
+        this.pollIntervalMs = 60 * 1000;
+        this.exceptLeadNode = true;
+    }
+    async pollHandler() {
+        // if transaction is pending for more than 1 hour, check lead node for status
+        const leadNode = net_1.peerPool.getLeadPeer();
+        if (!leadNode) {
+            return;
+        }
+        const transaction = await db_1.Transaction.findOne({
+            where: {
+                status: 'pending',
+                sourceCreatedAt: {
+                    [sequelize_1.Op.gte]: new Date(Date.now() - 60 * 60 * 1000),
+                },
+            }
+        });
+        if (!transaction) {
+            return;
+        }
+        this.logger.info(`Requesting transaction status for ${transaction.transactionHash}`);
+        const transactionStatus = await net_1.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}`);
+    }
+}
+exports.default = SyncTransactionStatusTask;

package/dist/src/tasks/index.js

@@ -4,12 +4,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 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 SyncWithdrawtEvents_1 = __importDefault(require("./InteropXGateway/SyncWithdrawtEvents"));
+const ProcessWithdrawEvents_1 = __importDefault(require("./InteropBridge/ProcessWithdrawEvents"));
+const SyncBurnEvents_1 = __importDefault(require("./InteropBridge/SyncBurnEvents"));
+const SyncMintEvents_1 = __importDefault(require("./InteropBridge/SyncMintEvents"));
+const SyncTransactionStatusTask_1 = __importDefault(require("./Transactions/SyncTransactionStatusTask"));
+const AutoUpdateTask_1 = __importDefault(require("./AutoUpdateTask"));
 class Tasks {
     constructor() {
         this.tasks = [
+            new SyncTransactionStatusTask_1.default(),
+            new AutoUpdateTask_1.default(),
+            // InteropXGateway
             new SyncDepositEvents_1.default({
                 chainId: 43114
+            }),
+            new ProcessDepositEvents_1.default({
+                chainId: 43114
+            }),
+            new SyncWithdrawtEvents_1.default({
+                chainId: 43114
+            }),
+            // InteropBridge
+            new ProcessWithdrawEvents_1.default({
+                chainId: 137,
+            }),
+            new SyncMintEvents_1.default({
+                chainId: 137,
+                itokenAddress: '0x62c0045f3277e7067cacad3c8038eeabb1bd92d1',
+            }),
+            new SyncBurnEvents_1.default({
+                chainId: 137,
+                itokenAddress: '0x62c0045f3277e7067cacad3c8038eeabb1bd92d1',
             })
         ];
     }

package/dist/src/typechain/factories/InteropBridgeToken__factory.js

@@ -57,11 +57,17 @@ const _abi = [
                 name: "amount",
                 type: "uint256",
             },
+            {
+                indexed: false,
+                internalType: "uint32",
+                name: "sourceChainId",
+                type: "uint32",
+            },
             {
                 indexed: true,
-                internalType: "uint256",
-                name: "chainId",
-                type: "uint256",
+                internalType: "uint32",
+                name: "targetChainId",
+                type: "uint32",
             },
         ],
         name: "Burn",
@@ -84,14 +90,20 @@ const _abi = [
             },
             {
                 indexed: true,
-                internalType: "uint256",
-                name: "chainId",
-                type: "uint256",
+                internalType: "uint32",
+                name: "sourceChainId",
+                type: "uint32",
+            },
+            {
+                indexed: false,
+                internalType: "uint32",
+                name: "targetChainId",
+                type: "uint32",
             },
             {
                 indexed: true,
                 internalType: "bytes32",
-                name: "transactionHash",
+                name: "submitTransactionHash",
                 type: "bytes32",
             },
         ],
@@ -222,9 +234,9 @@ const _abi = [
                 type: "uint256",
             },
             {
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "chainId",
-                type: "uint256",
+                type: "uint32",
             },
         ],
         name: "burn",
@@ -306,9 +318,9 @@ const _abi = [
                 type: "uint256",
             },
             {
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "chainId",
-                type: "uint256",
+                type: "uint32",
             },
             {
                 internalType: "bytes32",

package/dist/src/typechain/factories/InteropXGateway__factory.js

@@ -46,15 +46,15 @@ const _abi = [
             },
             {
                 indexed: false,
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "sourceChainId",
-                type: "uint256",
+                type: "uint32",
             },
             {
                 indexed: true,
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "targetChainId",
-                type: "uint256",
+                type: "uint32",
             },
         ],
         name: "LogGatewayDeposit",
@@ -83,15 +83,15 @@ const _abi = [
             },
             {
                 indexed: true,
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "sourceChainId",
-                type: "uint256",
+                type: "uint32",
             },
             {
                 indexed: false,
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "targetChainId",
-                type: "uint256",
+                type: "uint32",
             },
             {
                 indexed: true,
@@ -148,9 +148,9 @@ const _abi = [
                 type: "uint256",
             },
             {
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "chainId_",
-                type: "uint256",
+                type: "uint32",
             },
         ],
         name: "deposit",
@@ -176,9 +176,9 @@ const _abi = [
                 type: "uint256",
             },
             {
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "chainId_",
-                type: "uint256",
+                type: "uint32",
             },
         ],
         name: "depositFor",
@@ -224,9 +224,9 @@ const _abi = [
                 type: "address",
             },
             {
-                internalType: "uint256",
+                internalType: "uint32",
                 name: "chainId_",
-                type: "uint256",
+                type: "uint32",
             },
             {
                 internalType: "bytes32",

package/dist/src/utils/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDataForTransaction = exports.generateInteropTransactionHash = exports.asyncCallWithTimeout = exports.buildSignatureBytes = exports.getRpcProviderUrl = exports.signGnosisSafeTx = exports.short = exports.http = void 0;
+exports.getContract = exports.generateInteropTransactionHash = exports.asyncCallWithTimeout = exports.buildSignatureBytes = exports.getRpcProviderUrl = exports.signGnosisSafeTx = exports.short = exports.shortenHash = exports.http = void 0;
 /**
  * @module util
  */
@@ -11,11 +11,18 @@ const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importDefault(require("axios-retry"));
 const constants_1 = require("@/constants");
 const ethers_1 = require("ethers");
-const ethers_multisend_1 = require("ethers-multisend");
-const config_1 = __importDefault(require("@/config"));
-const abi_1 = __importDefault(require("@/abi"));
 exports.http = axios_1.default.create();
 (0, axios_retry_1.default)(exports.http, { retries: 3, retryDelay: axios_retry_1.default.exponentialDelay });
+function shortenHash(hash, length = 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;
+}
+exports.shortenHash = shortenHash;
 function short(buffer) {
     return buffer.toString('hex').slice(0, 8) + '...';
 }
@@ -59,11 +66,11 @@ exports.signGnosisSafeTx = signGnosisSafeTx;
 const getRpcProviderUrl = (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}`);
     }
@@ -102,36 +109,49 @@ const generateInteropTransactionHash = (data) => {
     ]);
 };
 exports.generateInteropTransactionHash = generateInteropTransactionHash;
-const buildDataForTransaction = async (transaction, type) => {
-    type = type || transaction.sourceStatus === 'pending' ? 'source' : 'target';
-    const transactions = [];
-    if (transaction.action != 'deposit') {
-        throw new Error('Invalid 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');
+function getContract(address, contractInterface, signerOrProvider) {
+    if (!ethers_1.ethers.utils.getAddress(address) || address === ethers_1.ethers.constants.AddressZero) {
+        throw Error(`Invalid 'address' parameter '${address}'.`);
     }
-    const token = constants_1.tokens[transaction.sourceChainId].find(token => token.address.toLowerCase() === transaction.submitEvent.token.toLowerCase());
-    if (!token) {
-        throw Error('Cannot build data for transaction without token');
+    const contract = new ethers_1.ethers.Contract(address, contractInterface, signerOrProvider);
+    // Make sure the contract properties is writable
+    const desc = Object.getOwnPropertyDescriptor(contract, 'functions');
+    if (!desc || desc.writable !== true) {
+        return contract;
     }
-    const itoken = constants_1.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_1.ethers.providers.JsonRpcProvider((0, exports.getRpcProviderUrl)(transaction.targetChainId));
-    const targetWallet = new ethers_1.ethers.Wallet(config_1.default.privateKey, targetChainProvider);
-    const interopBridgeContract = new ethers_1.ethers.Contract(itoken.address, abi_1.default.interopBridgeToken, targetWallet);
-    const { data } = await interopBridgeContract.populateTransaction.mint(transaction.submitEvent.to, transaction.submitEvent.amount, transaction.sourceChainId, transaction.sourceTransactionHash);
-    transactions.push({
-        to: itoken.address,
-        data: data,
-        value: '0',
-        operation: ethers_multisend_1.OperationType.Call,
+    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) => {
+                    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) => {
+                                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;
+        },
     });
-    return (0, ethers_multisend_1.encodeMulti)(transactions).data;
-};
-exports.buildDataForTransaction = buildDataForTransaction;
+}
+exports.getContract = getContract;