@instadapp/interop-x 0.0.0-dev.0134f74

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,109 @@
+"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 chalk_1 = __importDefault(require("chalk"));
+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:", chalk_1.default.bold(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);

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

@@ -0,0 +1,130 @@
+"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"));
+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() {
+        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) {
+            const newPeer = !this.pool.get(peer.id);
+            this.pool.set(peer.id, peer);
+            peer.pooled = true;
+            if (newPeer) {
+                config_1.default.events.emit(types_1.Event.POOL_PEER_ADDED, peer);
+                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`);
+            }
+        }
+    }
+    /**
+     * 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);
+                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`);
+            }
+        }
+    }
+    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);
+    }
+    getPeer(id) {
+        return this.pool.get(id);
+    }
+    isLeadNode(id) {
+        const peer = this.pool.get(id);
+        if (!peer) {
+            return false;
+        }
+        return (0, utils_1.getAddress)(peer.publicAddress) === (0, utils_1.getAddress)(config_1.default.leadNodeAddress);
+    }
+    getLeadPeer() {
+        return this.peers.find((p) => this.isLeadNode(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();

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

@@ -0,0 +1,106 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDialProtocol = void 0;
+const it_pipe_1 = __importDefault(require("it-pipe"));
+const peer_id_1 = __importDefault(require("peer-id"));
+const utils_1 = require("@/utils");
+const waait_1 = __importDefault(require("waait"));
+class BaseDialProtocol {
+    constructor(libp2p, protocol) {
+        this.timeout = 20000;
+        this.libp2p = libp2p;
+        this.protocol = protocol;
+        this.libp2p.handle(this.protocol, this.handle.bind(this));
+    }
+    encode(data) {
+        return JSON.stringify(data);
+    }
+    encodeResponse(data) {
+        return JSON.stringify(data);
+    }
+    decode(data) {
+        return JSON.parse(data.toString());
+    }
+    decodeResponse(data) {
+        return JSON.parse(data.toString());
+    }
+    async response(data) {
+        return data;
+    }
+    async handle({ connection, stream }) {
+        const instance = this;
+        try {
+            await (0, it_pipe_1.default)(stream, async function (source) {
+                var e_1, _a;
+                try {
+                    for (var source_1 = __asyncValues(source), source_1_1; source_1_1 = await source_1.next(), !source_1_1.done;) {
+                        const message = source_1_1.value;
+                        const response = instance.encodeResponse(await instance.response(instance.decode(message)));
+                        await (0, it_pipe_1.default)([response], stream);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (source_1_1 && !source_1_1.done && (_a = source_1.return)) await _a.call(source_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    async send(data, peerId) {
+        return await (0, utils_1.asyncCallWithTimeout)(new Promise(async (resolve, reject) => {
+            try {
+                let connection = this.libp2p.connectionManager.get(peer_id_1.default.createFromB58String(peerId));
+                if (!connection) {
+                    await (0, waait_1.default)(5000);
+                    connection = this.libp2p.connectionManager.get(peer_id_1.default.createFromB58String(peerId));
+                    if (!connection) {
+                        await (0, waait_1.default)(3000);
+                        connection = this.libp2p.connectionManager.get(peer_id_1.default.createFromB58String(peerId));
+                        if (!connection) {
+                            throw new Error('No connection available');
+                        }
+                    }
+                }
+                const { stream } = await connection.newStream([this.protocol]);
+                const instance = this;
+                (0, it_pipe_1.default)([this.encode(data)], stream, async function (source) {
+                    var e_2, _a;
+                    try {
+                        for (var source_2 = __asyncValues(source), source_2_1; source_2_1 = await source_2.next(), !source_2_1.done;) {
+                            const message = source_2_1.value;
+                            resolve(instance.decodeResponse(message));
+                            stream.close();
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (source_2_1 && !source_2_1.done && (_a = source_2.return)) await _a.call(source_2);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        }), this.timeout);
+    }
+}
+exports.BaseDialProtocol = BaseDialProtocol;

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureDialProtocol = void 0;
+const BaseDialProtocol_1 = require("./BaseDialProtocol");
+const waait_1 = __importDefault(require("waait"));
+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;
+        do {
+            transaction = await db_1.Transaction.findOne({ where: { transactionHash: data.transactionHash } });
+            if (!transaction) {
+                await (0, waait_1.default)(1000);
+                maxTimeout -= 1000;
+            }
+        } while (!transaction && maxTimeout > 0);
+        if (!transaction) {
+            return {
+                signer: signer.address,
+                data: null,
+                error: 'Event not found'
+            };
+        }
+        const { data: gnosisData } = await (0, gnosis_1.buildGnosisAction)(transaction, data.type);
+        const signedData = await (0, utils_1.signGnosisSafeTx)({
+            to: constants_1.addresses[data.chainId].multisend,
+            data: gnosisData,
+            chainId: data.chainId,
+            safeTxGas: data.safeTxGas,
+            nonce: data.safeNonce,
+        }, { signer });
+        return {
+            signer: signer.address,
+            data: signedData
+        };
+    }
+}
+exports.SignatureDialProtocol = SignatureDialProtocol;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionStatusDialProtocol = void 0;
+const BaseDialProtocol_1 = require("./BaseDialProtocol");
+const db_1 = require("@/db");
+class TransactionStatusDialProtocol extends BaseDialProtocol_1.BaseDialProtocol {
+    constructor(libp2p) {
+        super(libp2p, '/interop-x/transaction-status');
+        this.timeout = 30000;
+    }
+    async response(transactionHash) {
+        const transaction = await db_1.Transaction.findOne({ where: { transactionHash } });
+        if (!transaction) {
+            return null;
+        }
+        return {
+            transactionHash: transaction.transactionHash,
+            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,
+        };
+    }
+}
+exports.TransactionStatusDialProtocol = TransactionStatusDialProtocol;