@instadapp/interop-x 0.0.0-dev.051cd4e

package/dist/src/constants/tokens.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokens = void 0;
+exports.tokens = {
+    1: [
+        {
+            symbol: "ETH",
+            name: "Ethereum",
+            address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+            decimals: 18,
+        },
+        {
+            symbol: "DAI",
+            name: "DAI Stable",
+            address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+            decimals: 18,
+        },
+        {
+            symbol: "USDC",
+            name: "USD Coin",
+            address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            decimals: 6,
+        },
+        {
+            symbol: "USDT",
+            name: "Tether USD Coin",
+            address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+            decimals: 6,
+        },
+        {
+            symbol: "WBTC",
+            name: "Wrapped BTC",
+            address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+            decimals: 8,
+        },
+    ],
+    137: [
+        {
+            symbol: "ETH",
+            name: "Ethereum",
+            address: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+            decimals: 18,
+        },
+        {
+            symbol: "DAI",
+            name: "DAI Stable",
+            address: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
+            decimals: 18,
+        },
+        {
+            symbol: "USDC",
+            name: "USD Coin",
+            address: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+            decimals: 6,
+        },
+        {
+            symbol: "USDT",
+            name: "Tether USD Coin",
+            address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+            decimals: 6,
+        },
+        {
+            symbol: "WBTC",
+            name: "Wrapped BTC",
+            address: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
+            decimals: 8,
+        },
+        {
+            symbol: "AVAX",
+            name: "Avalanche Token",
+            address: "0x2C89bbc92BD86F8075d1DEcc58C7F4E0107f286b",
+            decimals: 18,
+        },
+    ],
+    43114: [
+        {
+            symbol: "ETH",
+            name: "Ethereum",
+            address: "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB",
+            decimals: 18,
+        },
+        {
+            symbol: "DAI",
+            name: "DAI Stable",
+            address: "0xd586E7F844cEa2F87f50152665BCbc2C279D8d70",
+            decimals: 18,
+        },
+        {
+            symbol: "USDC",
+            name: "USD Coin",
+            address: "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664",
+            decimals: 6,
+        },
+        {
+            symbol: "USDT",
+            name: "Tether USD Coin",
+            address: "0xc7198437980c041c805A1EDcbA50c1Ce5db95118",
+            decimals: 6,
+        },
+        {
+            symbol: "WBTC",
+            name: "Wrapped BTC",
+            address: "0x50b7545627a5162F82A992c33b87aDc75187B218",
+            decimals: 8,
+        },
+    ],
+};

package/dist/src/db/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("./models"), exports);

package/dist/src/db/models/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("./transaction"), exports);

package/dist/src/db/models/transaction.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const sequelize_1 = require("@/db/sequelize");
+const sequelize_2 = require("sequelize");
+class Transaction extends sequelize_2.Model {
+}
+exports.Transaction = Transaction;
+Transaction.init({
+    id: {
+        type: sequelize_2.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+    },
+    submitTransactionHash: sequelize_2.DataTypes.NUMBER,
+    submitBlockNumber: sequelize_2.DataTypes.NUMBER,
+    transactionHash: sequelize_2.DataTypes.STRING,
+    action: sequelize_2.DataTypes.STRING,
+    from: sequelize_2.DataTypes.STRING,
+    to: sequelize_2.DataTypes.STRING,
+    sourceChainId: sequelize_2.DataTypes.NUMBER,
+    sourceTransactionHash: sequelize_2.DataTypes.STRING,
+    sourceBlockNumber: sequelize_2.DataTypes.NUMBER,
+    sourceStatus: sequelize_2.DataTypes.STRING,
+    sourceErrors: {
+        type: sequelize_2.DataTypes.JSON,
+        // defaultValue: [],
+    },
+    sourceCreatedAt: {
+        type: sequelize_2.DataTypes.DATE,
+        defaultValue: Date.now()
+    },
+    sourceDelayUntil: sequelize_2.DataTypes.STRING,
+    targetChainId: sequelize_2.DataTypes.NUMBER,
+    targetTransactionHash: sequelize_2.DataTypes.STRING,
+    targetBlockNumber: sequelize_2.DataTypes.NUMBER,
+    targetStatus: sequelize_2.DataTypes.STRING,
+    targetErrors: {
+        type: sequelize_2.DataTypes.JSON,
+        // defaultValue: [],
+    },
+    targetCreatedAt: sequelize_2.DataTypes.DATE,
+    targetDelayUntil: sequelize_2.DataTypes.DATE,
+    submitEvent: sequelize_2.DataTypes.JSON,
+    sourceEvent: sequelize_2.DataTypes.JSON,
+    targetEvent: sequelize_2.DataTypes.JSON,
+    metadata: sequelize_2.DataTypes.JSON,
+    status: {
+        type: sequelize_2.DataTypes.STRING,
+        defaultValue: 'pending'
+    },
+    createdAt: sequelize_2.DataTypes.DATE,
+    updatedAt: sequelize_2.DataTypes.DATE,
+}, { sequelize: sequelize_1.sequelize, tableName: 'transactions' });

package/dist/src/db/sequelize.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequelize = void 0;
+//@ts-ignore
+const config_1 = __importDefault(require("@/config"));
+const expand_home_dir_1 = __importDefault(require("expand-home-dir"));
+const sequelize_1 = require("sequelize");
+const basePath = (0, expand_home_dir_1.default)(`~/.interop-x/data/${config_1.default.publicAddress}/${config_1.default.staging ? 'staging' : ''}`);
+exports.sequelize = new sequelize_1.Sequelize({
+    dialect: 'sqlite',
+    storage: `${basePath}/localDB.sqlite`,
+    // dialectModulePath: '@journeyapps/sqlcipher',
+    logging: false,
+});
+exports.sequelize.sync({
+    alter: true
+}).then(() => {
+    //     sequelize.query('PRAGMA cipher_compatibility = 3');
+    //     sequelize.query("PRAGMA key = 'your-encryption-key'");
+});

package/dist/src/index.js

@@ -0,0 +1,103 @@
+"use strict";
+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)();
+const dotenv_1 = __importDefault(require("dotenv"));
+const chalk_1 = __importDefault(require("chalk"));
+const ethers_1 = require("ethers");
+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 printUsage = () => {
+    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');
+};
+if (process.argv.at(-1) === 'help') {
+    printUsage();
+    process.exit(0);
+}
+const GIT_SHORT_HASH = '051cd4e';
+if (process.argv.at(-1) === 'version') {
+    console.log(`Interop X Node (v${package_json_1.default.version} - rev.${GIT_SHORT_HASH})`);
+    process.exit(0);
+}
+if (!process.env.PRIVATE_KEY) {
+    console.error(chalk_1.default.bgRed.white.bold('Please provide a private key\n'));
+    printUsage();
+    process.exit(1);
+}
+try {
+    new ethers_1.ethers.Wallet(process.env.PRIVATE_KEY);
+}
+catch (e) {
+    console.error(chalk_1.default.bgRed.white('Invalid private key\n'));
+    printUsage();
+    process.exit(1);
+}
+logger.debug(`Starting Interop X Node (v${package_json_1.default.version} - rev.${GIT_SHORT_HASH})`);
+const tasks_1 = require("@/tasks");
+const net_1 = require("@/net");
+const api_1 = require("@/api");
+const db_1 = require("./db");
+async function main() {
+    (0, net_1.startPeer)({});
+    const tasks = new tasks_1.Tasks();
+    tasks.start();
+    (0, api_1.startApiServer)();
+    net_1.protocol.on('TransactionStatus', async (payload) => {
+        if (!net_1.peerPool.isLeadNode(payload.peerId)) {
+            const peer = net_1.peerPool.getPeer(payload.peerId);
+            logger.info(`ignored transaction status from ${payload.peerId} ${peer === null || peer === void 0 ? void 0 : peer.publicAddress} `);
+            return;
+        }
+        const transaction = await db_1.Transaction.findOne({ where: { transactionHash: payload.data.transactionHash } });
+        if (!transaction) {
+            return;
+        }
+        transaction.sourceStatus = payload.data.sourceStatus;
+        transaction.sourceTransactionHash = payload.data.sourceTransactionHash;
+        transaction.sourceErrors = payload.data.sourceErrors;
+        transaction.targetStatus = payload.data.targetStatus;
+        transaction.targetTransactionHash = payload.data.targetTransactionHash;
+        transaction.targetErrors = payload.data.targetErrors;
+        transaction.status = payload.data.status;
+        await transaction.save();
+    });
+}
+main()
+    .then(() => {
+}).catch(err => {
+    console.error(err);
+});
+process.on('SIGINT', () => {
+    logger.debug('received SIGINT signal. exiting.');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.debug('received SIGTERM signal. exiting.');
+    process.exit(0);
+});
+process.on('unhandledRejection', (reason, p) => {
+    logger.error('unhandled rejection: promise:', p, 'reason:', reason);
+});

package/dist/src/logger/index.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLogLevel = exports.LogLevels = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const luxon_1 = require("luxon");
+var LogLevels;
+(function (LogLevels) {
+    LogLevels[LogLevels["Critical"] = 0] = "Critical";
+    LogLevels[LogLevels["Error"] = 1] = "Error";
+    LogLevels[LogLevels["Warn"] = 2] = "Warn";
+    LogLevels[LogLevels["Info"] = 3] = "Info";
+    LogLevels[LogLevels["Log"] = 4] = "Log";
+    LogLevels[LogLevels["Debug"] = 5] = "Debug";
+})(LogLevels = exports.LogLevels || (exports.LogLevels = {}));
+const logLevelColors = {
+    [LogLevels.Critical]: 'red',
+    [LogLevels.Error]: 'red',
+    [LogLevels.Warn]: 'yellow',
+    [LogLevels.Info]: 'blue',
+    [LogLevels.Log]: 'white',
+    [LogLevels.Debug]: 'white'
+};
+let logLevel = LogLevels.Debug;
+const setLogLevel = (_logLevel) => {
+    if (typeof _logLevel === 'string') {
+        const mapping = {
+            error: LogLevels.Error,
+            warn: LogLevels.Warn,
+            info: LogLevels.Info,
+            debug: LogLevels.Debug
+        };
+        _logLevel = mapping[_logLevel];
+    }
+    logLevel = _logLevel;
+};
+exports.setLogLevel = setLogLevel;
+class Logger {
+    constructor(tag = '', opts = {
+        color: 'white'
+    }) {
+        var _a;
+        this.tag = '';
+        this.prefix = '';
+        this.options = {};
+        this.enabled = true;
+        this.critical = (...input) => {
+            if (!this.enabled)
+                return;
+            console.error(...this.headers(LogLevels.Critical), ...input);
+        };
+        this.debug = (...input) => {
+            if (!this.enabled)
+                return;
+            if (logLevel !== LogLevels.Debug) {
+                return;
+            }
+            console.debug(...this.headers(LogLevels.Debug), ...input);
+        };
+        this.error = (...input) => {
+            if (!this.enabled)
+                return;
+            console.error(...this.headers(LogLevels.Error), ...input);
+        };
+        this.info = (...input) => {
+            if (!this.enabled)
+                return;
+            if (!(logLevel === LogLevels.Debug || logLevel === LogLevels.Info)) {
+                return;
+            }
+            console.info(...this.headers(LogLevels.Info), ...input);
+        };
+        this.log = (...input) => {
+            if (!this.enabled)
+                return;
+            if (logLevel < LogLevels.Info) {
+                return;
+            }
+            console.log(...this.headers(LogLevels.Log), ...input);
+        };
+        this.warn = (...input) => {
+            if (!this.enabled)
+                return;
+            if (logLevel < LogLevels.Warn) {
+                return;
+            }
+            console.warn(...this.headers(LogLevels.Warn), ...input);
+        };
+        if (tag instanceof Object) {
+            opts = tag;
+            tag = (_a = opts.tag) !== null && _a !== void 0 ? _a : '';
+        }
+        if (opts.prefix) {
+            this.prefix = `<${opts.prefix}>`;
+        }
+        if (tag) {
+            if (opts.color) {
+                //@ts-ignore
+                this.tag = chalk_1.default[opts.color](`[${tag}]`);
+            }
+            else {
+                this.tag = `[${tag}]`;
+            }
+        }
+        if (process.env.DISABLE_LOGGER) {
+            this.enabled = false;
+        }
+        this.options = opts;
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    create(additionalDataLabel) {
+        let label;
+        if (additionalDataLabel.id) {
+            label = `id: ${additionalDataLabel.id}`;
+        }
+        else {
+            label = `root: ${additionalDataLabel.root}`;
+        }
+        return new Logger(this.options.tag, Object.assign({}, this.options, {
+            prefix: `${this.options.prefix ? `${this.options.prefix} ` : ''}${label}`
+        }));
+    }
+    get timestamp() {
+        return luxon_1.DateTime.now().toISO();
+    }
+    headers(logLevelEnum) {
+        const keys = Object.keys(LogLevels);
+        const logLevelName = keys[logLevelEnum + keys.length / 2].toUpperCase();
+        //@ts-ignore
+        const coloredLogLevel = chalk_1.default[logLevelColors[logLevelEnum]](logLevelName.padEnd(5, ' '));
+        return [this.timestamp, coloredLogLevel, this.tag, this.prefix];
+    }
+}
+exports.default = Logger;

package/dist/src/net/index.js

@@ -0,0 +1,19 @@
+"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("./peer"), exports);
+__exportStar(require("./pool"), exports);
+__exportStar(require("./protocol"), exports);

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

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopPeer = exports.startPeer = void 0;
+const libp2p_1 = __importDefault(require("libp2p"));
+const libp2p_tcp_1 = __importDefault(require("libp2p-tcp"));
+//@ts-ignore
+const libp2p_websockets_1 = __importDefault(require("libp2p-websockets"));
+//@ts-ignore
+const libp2p_mplex_1 = __importDefault(require("libp2p-mplex"));
+const libp2p_noise_1 = require("libp2p-noise");
+const logger_1 = __importDefault(require("@/logger"));
+const libp2p_bootstrap_1 = __importDefault(require("libp2p-bootstrap"));
+const waait_1 = __importDefault(require("waait"));
+const libp2p_gossipsub_1 = __importDefault(require("@achingbrain/libp2p-gossipsub"));
+//@ts-ignore
+const libp2p_mdns_1 = __importDefault(require("libp2p-mdns"));
+//@ts-ignore
+const libp2p_kad_dht_1 = __importDefault(require("libp2p-kad-dht"));
+//@ts-ignore
+const libp2p_pubsub_peer_discovery_1 = __importDefault(require("libp2p-pubsub-peer-discovery"));
+const net_1 = require("@/net");
+const config_1 = __importDefault(require("@/config"));
+const logger = new logger_1.default("Peer");
+let node;
+// Known peers addresses
+const bootstrapMultiaddrs = [
+    '/ip4/164.92.249.133/tcp/15001/ws/p2p/QmVGmkqRn8FEw4PQz83L8Mun24ALxXB2fEyS5aEfT2gGqz',
+    '/ip4/164.92.249.133/tcp/15000/p2p/QmVGmkqRn8FEw4PQz83L8Mun24ALxXB2fEyS5aEfT2gGqz',
+];
+const startPeer = async ({}) => {
+    node = await libp2p_1.default.create({
+        addresses: {
+            listen: ["/ip4/0.0.0.0/tcp/0", "/ip4/0.0.0.0/tcp/0/ws"],
+        },
+        modules: {
+            transport: [libp2p_tcp_1.default, libp2p_websockets_1.default],
+            streamMuxer: [libp2p_mplex_1.default],
+            connEncryption: [libp2p_noise_1.NOISE],
+            peerDiscovery: [libp2p_mdns_1.default, libp2p_bootstrap_1.default, libp2p_pubsub_peer_discovery_1.default],
+            pubsub: libp2p_gossipsub_1.default,
+            dht: libp2p_kad_dht_1.default,
+        },
+        config: {
+            dht: {
+                enabled: true,
+            },
+            peerDiscovery: {
+                autoDial: true,
+                // The `tag` property will be searched when creating the instance of your Peer Discovery service.
+                // The associated object, will be passed to the service when it is instantiated.
+                [libp2p_bootstrap_1.default.tag]: {
+                    enabled: true,
+                    interval: 60e3,
+                    list: bootstrapMultiaddrs, // provide array of multiaddrs
+                },
+                [libp2p_mdns_1.default.tag]: {
+                    interval: 20e3,
+                    enabled: true,
+                },
+                [libp2p_pubsub_peer_discovery_1.default.tag]: {
+                    interval: 1000,
+                    enabled: true,
+                },
+            },
+            relay: {
+                enabled: true,
+                autoRelay: {
+                    enabled: true,
+                    maxListeners: 10,
+                },
+            },
+        },
+        peerStore: {
+            persistence: true,
+        },
+    });
+    logger.info("Peer ID:", node.peerId.toB58String());
+    await node.start();
+    net_1.protocol.start({
+        libp2p: node
+    });
+    node.on("peer:discovery", (peer) => {
+        // logger.log(`Discovered peer ${peer}`)
+    }); // peer disc.
+    node.connectionManager.on("peer:connect", (connection) => {
+        // logger.log(`Connected to ${connection.remotePeer.toB58String()}`)
+    });
+    logger.log("Peer discovery started");
+    await (0, waait_1.default)(1000);
+    setInterval(() => net_1.protocol.sendPeerInfo({
+        publicAddress: config_1.default.wallet.address,
+    }), 5000);
+};
+exports.startPeer = startPeer;
+const stopPeer = async () => {
+    if (node) {
+        // stop libp2p
+        await node.stop();
+        logger.log("libp2p has stopped");
+    }
+    process.exit(0);
+};
+exports.stopPeer = stopPeer;
+process.on("SIGTERM", exports.stopPeer);
+process.on("SIGINT", exports.stopPeer);