@instadapp/interop-x 0.0.0-dev.30b0db0 → 0.0.0-dev.31e1c6f

package/dist/src/gnosis/actions/aaveV3/source.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abi_1 = __importDefault(require("@/abi"));
+const config_1 = __importDefault(require("@/config"));
+const constants_1 = require("@/constants");
+const providers_1 = require("@/providers");
+const utils_1 = require("@/utils");
+const ethers_1 = require("ethers");
+const ethers_multisend_1 = require("ethers-multisend");
+async function default_1(transaction) {
+    const transactions = [];
+    const logs = [];
+    const { position, actionId, actionIdHashHash, sourceSender, sourceDsaId, targetDsaId, sourceChainId, targetChainId, vnonce, metadata, } = transaction.submitEvent;
+    const sourceChainProvider = new providers_1.JsonRpcRetryProvider((0, utils_1.getRpcProviderUrl)(sourceChainId));
+    const sourceWallet = new ethers_1.ethers.Wallet(config_1.default.privateKey, sourceChainProvider);
+    const dsaAddress = constants_1.addresses[sourceChainId].dsaAddress;
+    const sourceUserAddress = Number(sourceDsaId) == 0 ? sourceSender : dsaAddress;
+    const interopAddress = constants_1.addresses[sourceChainId].interopX;
+    const contract = (0, utils_1.getContract)(interopAddress, abi_1.default.interopX, sourceWallet);
+    const sourceSpells = [];
+    const commonSpells = [];
+    for (const withdraw of position.withdraw) {
+        let spellData = {
+            connector: "AAVE-V3-A",
+            method: "payback",
+            args: [withdraw.sourceToken, withdraw.amount, "2", "0", "0"],
+        };
+        sourceSpells.push({
+            connector: spellData.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellData),
+        });
+        let spellDataBasicWithdraw = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [withdraw.sourceToken, withdraw.amount, sourceUserAddress, "0", "0"],
+        };
+        commonSpells.push({
+            connector: spellDataBasicWithdraw.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellDataBasicWithdraw),
+        });
+    }
+    for (const supply of position.supply) {
+        let spellDataWithdraw = {
+            connector: "AAVE-V3-A",
+            method: "withdraw",
+            args: [supply.sourceToken, supply.amount, "0", "0"],
+        };
+        sourceSpells.push({
+            connector: spellDataWithdraw.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellDataWithdraw),
+        });
+        let spellDataBasicWithdraw = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [supply.sourceToken, supply.amount, dsaAddress, "0", "0"],
+        };
+        sourceSpells.push({
+            connector: spellDataBasicWithdraw.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellDataBasicWithdraw),
+        });
+    }
+    const { data } = await contract.populateTransaction.sourceAction(sourceSpells, commonSpells, position, actionId, sourceSender, sourceDsaId, targetDsaId, sourceChainId, targetChainId, vnonce, metadata);
+    transactions.push({
+        to: interopAddress,
+        data: data,
+        value: "0",
+        operation: ethers_multisend_1.OperationType.Call,
+    });
+    return { transactions, logs };
+}
+exports.default = default_1;

package/dist/src/gnosis/actions/aaveV3/target.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abi_1 = __importDefault(require("@/abi"));
+const config_1 = __importDefault(require("@/config"));
+const constants_1 = require("@/constants");
+const providers_1 = require("@/providers");
+const utils_1 = require("@/utils");
+const ethers_1 = require("ethers");
+const ethers_multisend_1 = require("ethers-multisend");
+async function default_1(transaction) {
+    const transactions = [];
+    const logs = [];
+    const { sourceSpells, position, actionId, sourceSender, sourceDsaId, targetDsaId, sourceChainId, targetChainId, vnonce, metadata, } = transaction.validateEvent;
+    const targetChainProvider = new providers_1.JsonRpcRetryProvider((0, utils_1.getRpcProviderUrl)(targetChainId));
+    const targetWallet = new ethers_1.ethers.Wallet(config_1.default.privateKey, targetChainProvider);
+    const targetInstListContract = (0, utils_1.getContract)(constants_1.addresses[targetChainId].instList, abi_1.default.instList, targetChainProvider);
+    const targetDsaAddress = await targetInstListContract.accountAddr(targetDsaId);
+    const dsaAddress = constants_1.addresses[targetChainId].dsaAddress;
+    const interopAddress = constants_1.addresses[targetChainId].interopX;
+    const contract = (0, utils_1.getContract)(interopAddress, abi_1.default.interopX, targetWallet);
+    const targetSpells = [];
+    const commonSpells = [];
+    for (const supplyToken of position.supply) {
+        let spellData = {
+            connector: "AAVE-V3-A",
+            method: "deposit",
+            args: [supplyToken.targetToken, supplyToken.amount, "0", "0"],
+        };
+        targetSpells.push({
+            connector: spellData.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellData),
+        });
+        let spellDataBasicWithdraw = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [supplyToken.targetToken, supplyToken.amount, targetDsaAddress, "0", "0"],
+        };
+        commonSpells.push({
+            connector: spellDataBasicWithdraw.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellDataBasicWithdraw),
+        });
+    }
+    for (const withdrawToken of position.withdraw) {
+        let spellData = {
+            connector: "AAVE-V3-A",
+            method: "borrow",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                "2",
+                "0",
+                "0",
+            ],
+        };
+        targetSpells.push({
+            connector: spellData.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellData),
+        });
+        let spellData2 = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                dsaAddress,
+                "0",
+                "0",
+            ],
+        };
+        targetSpells.push({
+            connector: spellData.connector,
+            data: (0, utils_1.encodeConnectorMethod)(spellData2),
+        });
+    }
+    const { data } = await contract.populateTransaction.targetAction(sourceSpells, targetSpells, commonSpells, position, actionId, sourceSender, sourceDsaId, targetDsaId, sourceChainId, targetChainId, vnonce, metadata);
+    transactions.push({
+        to: interopAddress,
+        data: data,
+        value: "0",
+        operation: ethers_multisend_1.OperationType.Call,
+    });
+    return { transactions, logs };
+}
+exports.default = default_1;

package/dist/src/gnosis/actions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const aaveV2_1 = __importDefault(require("./aaveV2"));
+const aaveV3_1 = __importDefault(require("./aaveV3"));
+exports.default = {
+    'A:AAVE-V2:AAVE-V2': aaveV2_1.default,
+    'A:AAVE-V3:AAVE-V3': aaveV3_1.default,
+};

package/dist/src/gnosis/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGnosisAction = void 0;
+const ethers_multisend_1 = require("ethers-multisend");
+const actions_1 = __importDefault(require("./actions"));
+const buildGnosisAction = async (transaction, type) => {
+    // type = type || (transaction.sourceStatus === 'success' ? 'target' : 'source')
+    if (actions_1.default.hasOwnProperty(transaction.actionId)) {
+        const { transactions, logs } = await actions_1.default[transaction.actionId](transaction, type);
+        return {
+            data: (0, ethers_multisend_1.encodeMulti)(transactions).data,
+            logs
+        };
+    }
+    throw new Error(`Unknown action: ${transaction.actionId}`);
+};
+exports.buildGnosisAction = buildGnosisAction;

package/dist/src/index.js

@@ -3,22 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const module_alias_1 = __importDefault(require("module-alias"));
-module_alias_1.default.addAliases({
-    "@/": __dirname + "/",
-    "@/logger": __dirname + "/logger",
-    "@/tasks": __dirname + "/tasks",
-    "@/utils": __dirname + "/utils",
-    "@/api": __dirname + "/api",
-    "@/net": __dirname + "/net",
-    "@/db": __dirname + "/db",
-    "@/config": __dirname + "/config",
-    "@/types": __dirname + "/types",
-    "@/abi": __dirname + "/abi",
-    "@/constants": __dirname + "/constants",
-    "@/typechain": __dirname + "/typechain"
-});
-(0, module_alias_1.default)();
+require("./alias");
+const expand_home_dir_1 = __importDefault(require("expand-home-dir"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const chalk_1 = __importDefault(require("chalk"));
 const ethers_1 = require("ethers");
@@ -26,18 +13,39 @@ const package_json_1 = __importDefault(require("../package.json"));
 dotenv_1.default.config();
 const logger_1 = __importDefault(require("@/logger"));
 const logger = new logger_1.default('Process');
+const GIT_SHORT_HASH = '31e1c6f';
 const printUsage = () => {
+    console.log();
+    console.log(`Interop X Node (v${package_json_1.default.version} - rev.${GIT_SHORT_HASH})`);
+    console.log();
     console.log('Usage:');
-    console.log('   PRIVATE_KEY=abcd1234 interop-x');
-    console.log('   PRIVATE_KEY=abcd1234 STAGING=true interop-x');
-    console.log('   PRIVATE_KEY=abcd1234 AUTO_UPDATE=true interop-x');
-    console.log('   PRIVATE_KEY=abcd1234 API_HOST=0.0.0.0 API_PORT=8080 interop-x');
+    console.log('   interop-x help                                                              Show this message');
+    console.log('   interop-x version                                                           Print out the installed version of Interop X');
+    console.log();
+    console.log('   interop-x down                                                              Put the node into maintenance mode');
+    console.log('   interop-x up                                                                Take the node out of maintenance mode');
+    console.log();
+    console.log('   PRIVATE_KEY=abcd1234 interop-x                                              Start the node with the given private key');
+    console.log('   PRIVATE_KEY=abcd1234 STAGING=true interop-x                                 Start the node in staging mode');
+    console.log('   PRIVATE_KEY=abcd1234 AUTO_UPDATE=true interop-x                             Start the node in auto update mode');
+    console.log('   PRIVATE_KEY=abcd1234 API_HOST=0.0.0.0 API_PORT=8080 interop-x               Start the node with custom API host and port');
+    console.log();
 };
 if (process.argv.at(-1) === 'help') {
     printUsage();
     process.exit(0);
 }
-const GIT_SHORT_HASH = '30b0db0';
+const basePath = (0, expand_home_dir_1.default)(`~/.interop-x`);
+if (process.argv.at(-1) === 'down') {
+    fs_extra_1.default.outputFileSync(basePath + '/maintenance', Date.now().toString());
+    console.log(chalk_1.default.red('Maintenance mode enabled'));
+    process.exit(0);
+}
+if (process.argv.at(-1) === 'up') {
+    fs_extra_1.default.removeSync(basePath + '/maintenance');
+    console.log(chalk_1.default.green('Maintenance mode disabled'));
+    process.exit(0);
+}
 if (process.argv.at(-1) === 'version') {
     console.log(`Interop X Node (v${package_json_1.default.version} - rev.${GIT_SHORT_HASH})`);
     process.exit(0);
@@ -61,10 +69,13 @@ const net_1 = require("@/net");
 const api_1 = require("@/api");
 const db_1 = require("./db");
 const utils_1 = require("./utils");
+require("./crons");
 async function main() {
     (0, net_1.startPeer)({});
     const tasks = new tasks_1.Tasks();
-    tasks.start();
+    setTimeout(() => {
+        tasks.start();
+    }, 10000);
     (0, api_1.startApiServer)();
     net_1.protocol.on('TransactionStatus', async (payload) => {
         if (!net_1.peerPool.isLeadNode(payload.peerId)) {
@@ -82,9 +93,11 @@ async function main() {
         transaction.sourceStatus = payload.data.sourceStatus;
         transaction.sourceTransactionHash = payload.data.sourceTransactionHash;
         transaction.sourceErrors = payload.data.sourceErrors;
+        transaction.sourceLogs = payload.data.sourceLogs;
         transaction.targetStatus = payload.data.targetStatus;
         transaction.targetTransactionHash = payload.data.targetTransactionHash;
         transaction.targetErrors = payload.data.targetErrors;
+        transaction.targetLogs = payload.data.targetLogs;
         transaction.status = payload.data.status;
         await transaction.save();
     });

package/dist/src/net/peer/index.js

@@ -23,6 +23,7 @@ const libp2p_kad_dht_1 = __importDefault(require("libp2p-kad-dht"));
 const libp2p_pubsub_peer_discovery_1 = __importDefault(require("libp2p-pubsub-peer-discovery"));
 const net_1 = require("@/net");
 const config_1 = __importDefault(require("@/config"));
+const chalk_1 = __importDefault(require("chalk"));
 const logger = new logger_1.default("Peer");
 let node;
 // Known peers addresses
@@ -77,7 +78,7 @@ const startPeer = async ({}) => {
             persistence: true,
         },
     });
-    logger.info("Peer ID:", node.peerId.toB58String());
+    logger.info("Peer ID:", chalk_1.default.bold(node.peerId.toB58String()));
     await node.start();
     net_1.protocol.start({
         libp2p: node

package/dist/src/net/pool/index.js

@@ -9,6 +9,7 @@ const config_1 = __importDefault(require("@/config"));
 const logger_1 = __importDefault(require("@/logger"));
 const utils_1 = require("ethers/lib/utils");
 const utils_2 = require("@/utils");
+const chalk_1 = __importDefault(require("chalk"));
 const logger = new logger_1.default('PeerPool');
 class PeerPool {
     constructor() {
@@ -72,7 +73,7 @@ class PeerPool {
             peer.pooled = true;
             if (newPeer) {
                 config_1.default.events.emit(types_1.Event.POOL_PEER_ADDED, peer);
-                logger.info(`Peer ${peer.id} with address ${(0, utils_2.shortenHash)(peer.publicAddress)} added to pool`);
+                logger.info(`Peer ${chalk_1.default.bold((0, utils_2.shortenHash)(peer.id, 16))} with address ${chalk_1.default.bold((0, utils_2.shortenHash)(peer.publicAddress))} added to pool`);
             }
         }
     }
@@ -86,7 +87,7 @@ class PeerPool {
             if (this.pool.delete(peer.id)) {
                 peer.pooled = false;
                 config_1.default.events.emit(types_1.Event.POOL_PEER_REMOVED, peer);
-                logger.info(`Peer ${peer.id} with address ${(0, utils_2.shortenHash)(peer.publicAddress)} removed from pool`);
+                logger.info(`Peer ${chalk_1.default.bold((0, utils_2.shortenHash)(peer.id, 16))} with address ${chalk_1.default.bold((0, utils_2.shortenHash)(peer.publicAddress))} removed from pool`);
             }
         }
     }

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

@@ -10,12 +10,17 @@ const config_1 = __importDefault(require("@/config"));
 const db_1 = require("@/db");
 const utils_1 = require("@/utils");
 const constants_1 = require("@/constants");
+const gnosis_1 = require("@/gnosis");
 class SignatureDialProtocol extends BaseDialProtocol_1.BaseDialProtocol {
     constructor(libp2p) {
         super(libp2p, '/interop-x/signatures');
         this.timeout = 30000;
     }
     async response(data) {
+        console.log({
+            tag: 'SignatureDialProtocol',
+            data
+        });
         const signer = config_1.default.wallet;
         let transaction;
         let maxTimeout = 20000;
@@ -33,17 +38,11 @@ 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 { data: gnosisData } = await (0, gnosis_1.buildGnosisAction)(transaction, data.type);
         const signedData = await (0, utils_1.signGnosisSafeTx)({
-            to: constants_1.addresses[transaction.targetChainId].multisend,
-            data: await (0, utils_1.buildDataForTransaction)(transaction, data.type),
-            chainId: transaction.targetChainId,
+            to: constants_1.addresses[data.chainId].multisend,
+            data: gnosisData,
+            chainId: data.chainId,
             safeTxGas: data.safeTxGas,
             nonce: data.safeNonce,
         }, { signer });

package/dist/src/net/protocol/dial/{SignatureDialProtocol.1.js → TransactionStatusDialProtocol.js}

@@ -18,9 +18,11 @@ class TransactionStatusDialProtocol extends BaseDialProtocol_1.BaseDialProtocol
             sourceStatus: transaction.sourceStatus,
             sourceTransactionHash: transaction.sourceTransactionHash,
             sourceErrors: transaction.sourceErrors,
+            sourceLogs: transaction.sourceLogs,
             targetStatus: transaction.targetStatus,
             targetTransactionHash: transaction.targetTransactionHash,
             targetErrors: transaction.targetErrors,
+            targetLogs: transaction.targetLogs,
             status: transaction.status,
         };
     }

package/dist/src/net/protocol/index.js

@@ -10,7 +10,7 @@ const SignatureDialProtocol_1 = require("./dial/SignatureDialProtocol");
 const __1 = require("..");
 const config_1 = __importDefault(require("@/config"));
 const types_1 = require("@/types");
-const SignatureDialProtocol_1_1 = require("./dial/SignatureDialProtocol.1");
+const TransactionStatusDialProtocol_1 = require("./dial/TransactionStatusDialProtocol");
 class Protocol extends stream_1.EventEmitter {
     constructor() {
         super(...arguments);
@@ -31,21 +31,31 @@ class Protocol extends stream_1.EventEmitter {
                 encode: (transaction) => [
                     Buffer.from(transaction.transactionHash),
                     Buffer.from(transaction.sourceStatus),
-                    Buffer.from(transaction.sourceTransactionHash),
+                    Buffer.from(transaction.sourceTransactionHash || ''),
                     transaction.sourceErrors ? transaction.sourceErrors.map((e) => Buffer.from(e)) : [],
+                    transaction.sourceLogs ? transaction.sourceLogs.map((e) => [Buffer.from(e.type), Buffer.from(e.message)]) : [],
                     Buffer.from(transaction.targetStatus),
-                    Buffer.from(transaction.targetTransactionHash),
+                    Buffer.from(transaction.targetTransactionHash || ''),
                     transaction.targetErrors ? transaction.targetErrors.map((e) => Buffer.from(e)) : [],
+                    transaction.targetLogs ? transaction.targetLogs.map((e) => [Buffer.from(e.type), Buffer.from(e.message)]) : [],
                     Buffer.from(transaction.status),
                 ],
-                decode: ([transactionHash, sourceStatus, sourceTransactionHash, sourceErrors, targetStatus, targetTransactionHash, targetErrors, status]) => ({
+                decode: ([transactionHash, sourceStatus, sourceTransactionHash, sourceErrors, sourceLogs, targetStatus, targetTransactionHash, targetErrors, targetLogs, status]) => ({
                     transactionHash: transactionHash.toString(),
                     sourceStatus: sourceStatus.toString(),
-                    sourceTransactionHash: sourceTransactionHash.toString(),
+                    sourceTransactionHash: sourceTransactionHash.toString() || null,
                     sourceErrors: sourceErrors.map((e) => e.toString()),
+                    sourceLogs: sourceLogs.map(e => ({
+                        type: e[0].toString(),
+                        message: e[1].toString(),
+                    })),
                     targetStatus: targetStatus.toString(),
-                    targetTransactionHash: targetTransactionHash.toString(),
+                    targetTransactionHash: targetTransactionHash.toString() || null,
                     targetErrors: targetErrors.map((e) => e.toString()),
+                    targetLogs: targetLogs.map(e => ({
+                        type: e[0].toString(),
+                        message: e[1].toString(),
+                    })),
                     status: status.toString(),
                 }),
             },
@@ -65,7 +75,7 @@ class Protocol extends stream_1.EventEmitter {
             });
         });
         this.signature = new SignatureDialProtocol_1.SignatureDialProtocol(this.libp2p);
-        this.transactionStatus = new SignatureDialProtocol_1_1.TransactionStatusDialProtocol(this.libp2p);
+        this.transactionStatus = new TransactionStatusDialProtocol_1.TransactionStatusDialProtocol(this.libp2p);
     }
     init() {
         this.libp2p.pubsub.subscribe(this.topic);

package/dist/src/providers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./retry-provider"), exports);

package/dist/src/providers/retry-provider.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcRetryProvider = exports.retryOperation = exports.promiseTimeout = void 0;
+const ethers_1 = require("ethers");
+const waait_1 = __importDefault(require("waait"));
+const bluebird_1 = __importDefault(require("bluebird"));
+function promiseTimeout(ms, promise) {
+    return bluebird_1.default.resolve(promise).timeout(ms);
+}
+exports.promiseTimeout = promiseTimeout;
+function retryOperation(retriesLeft, operation, options) {
+    return new Promise((resolve, reject) => {
+        const { timeouts } = options;
+        // Find the timeout for this specific iteration
+        const timeout = timeouts[timeouts.length - retriesLeft];
+        // Wrap the original operation in a timeout
+        const execution = promiseTimeout(timeout, operation());
+        // If the promise is successful, resolve it and bubble the result up
+        return execution.then(resolve).catch((reason) => {
+            // If there are any retries left, we call the same retryOperation function again,
+            // but decrementing the number of retries left by 1
+            if (retriesLeft - 1 > 0) {
+                // Delay the new attempt slightly
+                return (0, waait_1.default)(options.delay || 50)
+                    .then(retryOperation.bind(null, retriesLeft - 1, operation, options))
+                    .then(resolve)
+                    .catch(reject);
+            }
+            // Reject (and bubble the result up) if there are no more retries
+            return reject(reason);
+        });
+    });
+}
+exports.retryOperation = retryOperation;
+class JsonRpcRetryProvider extends ethers_1.ethers.providers.JsonRpcProvider {
+    perform(method, params) {
+        const timeouts = [5000, 10000];
+        const operation = () => super.perform(method, params);
+        return retryOperation(2, operation, { timeouts, delay: 50 });
+    }
+}
+exports.JsonRpcRetryProvider = JsonRpcRetryProvider;

package/dist/src/services/Prices.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_utils_1 = __importDefault(require("web3-utils"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const constants_1 = require("@/constants");
+const expand_home_dir_1 = __importDefault(require("expand-home-dir"));
+const config_1 = __importDefault(require("@/config"));
+const utils_1 = require("@/utils");
+const basePath = (0, expand_home_dir_1.default)(`~/.interop-x/data/${config_1.default.publicAddress}/${config_1.default.staging ? 'staging' : ''}`);
+const mainnetPricesFilePath = path_1.default.resolve(basePath, "./mainnetPrices.json");
+const networkTokenPricesFilePath = path_1.default.resolve(basePath, "./networkTokenPrices.json");
+class Prices {
+    static async fetch() {
+        if (!fs_1.default.existsSync(mainnetPricesFilePath)) {
+            fs_1.default.writeFileSync(mainnetPricesFilePath, JSON.stringify({}));
+        }
+        if (!fs_1.default.existsSync(networkTokenPricesFilePath)) {
+            fs_1.default.writeFileSync(networkTokenPricesFilePath, JSON.stringify({}));
+        }
+        this.mainnetPrices = JSON.parse(fs_1.default.readFileSync(mainnetPricesFilePath, "utf8"));
+        this.networkTokenPrices = JSON.parse(fs_1.default.readFileSync(networkTokenPricesFilePath, "utf8"));
+        try {
+            const path = constants_1.tokens["1"]
+                .filter((a) => a.symbol !== "ETH")
+                .map((token) => token.address)
+                .join(",");
+            const [response, ethResponse, avaxResponse, polygonResponse] = await Promise.all([
+                utils_1.http.get("https://api.coingecko.com/api/v3/simple/token_price/ethereum", {
+                    params: { contract_addresses: path, vs_currencies: "usd" },
+                }),
+                utils_1.http.get("https://api.coingecko.com/api/v3/simple/price", {
+                    params: { ids: "ethereum", vs_currencies: "usd" },
+                }),
+                utils_1.http.get("https://api.coingecko.com/api/v3/simple/price", {
+                    params: { ids: "avalanche-2", vs_currencies: "usd" },
+                }),
+                utils_1.http.get("https://api.coingecko.com/api/v3/simple/price", {
+                    params: { ids: "matic-network", vs_currencies: "usd" },
+                }),
+            ]);
+            this.networkTokenPrices = {
+                "1": ethResponse.data.ethereum.usd.toString(),
+                "137": polygonResponse.data["matic-network"].usd.toString(),
+                "43114": avaxResponse.data["avalanche-2"].usd.toString(),
+            };
+            const data = response.data;
+            for (const key in data) {
+                const _key = web3_utils_1.default.toChecksumAddress(key);
+                if (!data[key].usd)
+                    continue;
+                this.mainnetPrices[_key] = data[key].usd.toString();
+            }
+            this.mainnetPrices["0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"] =
+                ethResponse.data.ethereum.usd.toString();
+        }
+        catch (error) { }
+        fs_1.default.writeFileSync(mainnetPricesFilePath, JSON.stringify(this.mainnetPrices));
+        fs_1.default.writeFileSync(networkTokenPricesFilePath, JSON.stringify(this.networkTokenPrices));
+        return this.mainnetPrices;
+    }
+    static getMainnetPrices() {
+        return this.mainnetPrices;
+    }
+    static getNetworkTokenPrices() {
+        return this.networkTokenPrices;
+    }
+}
+Prices.mainnetPrices = {};
+Prices.networkTokenPrices = {};
+exports.default = Prices;

package/dist/src/services/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prices = void 0;
+var Prices_1 = require("./Prices");
+Object.defineProperty(exports, "Prices", { enumerable: true, get: function () { return __importDefault(Prices_1).default; } });