@instadapp/interop-x 0.0.0-dev.0ee2ee3

package/.env.example

@@ -0,0 +1 @@
+PRIVATE_KEY=

package/.github/workflows/publish-dev.yml

@@ -0,0 +1,30 @@
+name: Release Dev version
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "main"
+
+jobs:
+  npm-publish:
+    name: npm-publish
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - name: Resolve version
+        id: vars
+        run: echo "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+      - name: "Version based on commit: 0.0.0-dev.${{ steps.vars.outputs.sha_short }}"
+        run: npm version 0.0.0-dev.${{ steps.vars.outputs.sha_short }} --force --no-git-tag-version
+      - name: Build
+        run: yarn --frozen-lockfile && yarn run build
+      - name: Publish Dev Release
+        uses: JS-DevTools/npm-publish@v1
+        with:
+          token: ${{ secrets.NPM_AUTH_TOKEN }}
+          tag: latest # change it to dev after stable release
+          access: public

package/README.md

@@ -0,0 +1,21 @@
+# Interop X
+
+## Installation
+
+```bash
+npm install -g @instadapp/interop-x
+```
+
+## Usage
+
+### Show help
+
+```bash
+interop-x help
+```
+
+### Simple usage
+
+```bash
+PRIVATE_KEY=abcd1234 interop-x
+```

package/bin/interop-x

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/src/index')

package/dist/config/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const types_1 = require("types");
+class Config {
+    constructor() {
+        this.events = new types_1.EventBus();
+        this.maxPeers = 10;
+        this.privateKey = process.env.PRIVATE_KEY;
+        this.wallet = new ethers_1.Wallet(this.privateKey);
+        this.leadNodeAddress = '0x910E413DBF3F6276Fe8213fF656726bDc142E08E';
+    }
+    isLeadNode() {
+        return ethers_1.ethers.utils.getAddress(this.leadNodeAddress) === ethers_1.ethers.utils.getAddress(this.wallet.address);
+    }
+}
+exports.default = new Config();

package/dist/constants/addresses.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addresses = void 0;
+exports.addresses = {
+    1: {
+        gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
+        multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+    },
+    137: {
+        gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
+        multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+    },
+};

package/dist/constants/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("./addresses"), exports);

package/dist/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/db/models/execution.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Execution = void 0;
+const sequelize_1 = require("../sequelize");
+const sequelize_2 = require("sequelize");
+class Execution extends sequelize_2.Model {
+}
+exports.Execution = Execution;
+Execution.init({
+    id: {
+        type: sequelize_2.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+    },
+    transactionHash: sequelize_2.DataTypes.STRING,
+    from: sequelize_2.DataTypes.STRING,
+    executions: sequelize_2.DataTypes.JSON,
+    chainId: sequelize_2.DataTypes.NUMBER,
+    gas: sequelize_2.DataTypes.STRING,
+    maxGasPrice: sequelize_2.DataTypes.STRING,
+    assets: sequelize_2.DataTypes.JSON,
+    metadata: sequelize_2.DataTypes.STRING,
+    vnonce: sequelize_2.DataTypes.STRING,
+    txHash: sequelize_2.DataTypes.STRING,
+    blockNumber: sequelize_2.DataTypes.STRING,
+    status: {
+        type: sequelize_2.DataTypes.STRING,
+        defaultValue: 'pending'
+    },
+    delayUntil: sequelize_2.DataTypes.DATE,
+    delayedCount: {
+        type: sequelize_2.DataTypes.INTEGER,
+        defaultValue: 0
+    },
+    error: sequelize_2.DataTypes.STRING,
+    createdAt: sequelize_2.DataTypes.DATE,
+    updatedAt: sequelize_2.DataTypes.DATE,
+}, { sequelize: sequelize_1.sequelize, tableName: 'executions' });

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

package/dist/db/sequelize.js

@@ -0,0 +1,22 @@
+"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 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');
+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/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = require("console");
+const dotenv_1 = __importDefault(require("dotenv"));
+const tasks_1 = require("tasks");
+const logger_1 = __importDefault(require("./logger"));
+const net_1 = require("./net");
+dotenv_1.default.config();
+(0, console_1.assert)(process.env.PRIVATE_KEY, "PRIVATE_KEY is not defined");
+const logger = new logger_1.default('Process');
+async function main() {
+    (0, net_1.startPeer)({});
+    const tasks = new tasks_1.Tasks();
+    tasks.start();
+}
+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/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/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/net/peer/index.js

@@ -0,0 +1,100 @@
+"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 protocol_1 = require("../protocol");
+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();
+    protocol_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);
+};
+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);

package/dist/net/pool/index.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peerPool = exports.PeerPool = void 0;
+const types_1 = require("../../types");
+const config_1 = __importDefault(require("../../config"));
+class PeerPool {
+    constructor() {
+        this.PEERS_CLEANUP_TIME_LIMIT = 1;
+        this.pool = new Map();
+        config_1.default.events.on(types_1.Event.PEER_CONNECTED, (peer) => {
+            this.connected(peer);
+        });
+        config_1.default.events.on(types_1.Event.PEER_DISCONNECTED, (peer) => {
+            this.disconnected(peer);
+        });
+    }
+    /**
+     * Connected peers
+     */
+    get peers() {
+        const connectedPeers = Array.from(this.pool.values());
+        return connectedPeers;
+    }
+    /**
+     * Number of peers in pool
+     */
+    get size() {
+        return this.peers.length;
+    }
+    /**
+     * Return true if pool contains the specified peer
+     * @param peer peer object or id
+     */
+    contains(peer) {
+        if (typeof peer !== 'string') {
+            peer = peer.id;
+        }
+        return !!this.pool.get(peer);
+    }
+    /**
+     * Handler for peer connections
+     * @param peer peer
+     */
+    connected(peer) {
+        if (this.size >= config_1.default.maxPeers)
+            return;
+        this.add(peer);
+    }
+    /**
+     * Handler for peer disconnections
+     * @param peer peer
+     */
+    disconnected(peer) {
+        this.remove(peer);
+    }
+    /**
+     * Add peer to pool
+     * @param peer peer
+     * @emits {@link Event.POOL_PEER_ADDED}
+     */
+    add(peer) {
+        if (peer && peer.id && !this.pool.get(peer.id)) {
+            this.pool.set(peer.id, peer);
+            peer.pooled = true;
+            config_1.default.events.emit(types_1.Event.POOL_PEER_ADDED, peer);
+        }
+    }
+    /**
+     * Remove peer from pool
+     * @param peer peer
+     * @emits {@link Event.POOL_PEER_REMOVED}
+     */
+    remove(peer) {
+        if (peer && peer.id) {
+            if (this.pool.delete(peer.id)) {
+                peer.pooled = false;
+                config_1.default.events.emit(types_1.Event.POOL_PEER_REMOVED, peer);
+            }
+        }
+    }
+    get activePeers() {
+        this.cleanup();
+        return this.peers.filter((p) => {
+            if (!p.pooled)
+                return false;
+            const now = new Date();
+            return (now.getTime() - p.updated.getTime()) < 1000 * 10; // 10 seconds
+        });
+    }
+    get activePeerIds() {
+        return this.activePeers.map((p) => p.id);
+    }
+    cleanup() {
+        let compDate = Date.now() - this.PEERS_CLEANUP_TIME_LIMIT * 60;
+        this.peers.forEach((peerInfo) => {
+            if (peerInfo.updated.getTime() < compDate) {
+                console.log(`Peer ${peerInfo.id} idle for ${this.PEERS_CLEANUP_TIME_LIMIT} minutes`);
+                this.remove(peerInfo);
+            }
+        });
+    }
+}
+exports.PeerPool = PeerPool;
+exports.peerPool = new PeerPool();