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

package/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("module-alias/register");
+const assert_1 = __importDefault(require("assert"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const ethers_1 = require("ethers");
+dotenv_1.default.config();
+const logger_1 = __importDefault(require("@/logger"));
+const logger = new logger_1.default('Process');
+(0, assert_1.default)(process.env.PRIVATE_KEY, "PRIVATE_KEY is not defined");
+try {
+    new ethers_1.ethers.Wallet(process.env.PRIVATE_KEY);
+}
+catch (e) {
+    logger.error('Invalid private key');
+    process.exit(1);
+}
+const tasks_1 = require("@/tasks");
+const net_1 = require("@/net");
+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,104 @@
+"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);

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();

package/dist/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/net/protocol/dial/SignatureDialProtocol.js

@@ -0,0 +1,46 @@
+"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");
+class SignatureDialProtocol extends BaseDialProtocol_1.BaseDialProtocol {
+    constructor(libp2p) {
+        super(libp2p, '/interop-x/signatures');
+        this.timeout = 30000;
+    }
+    async response(data) {
+        const signer = config_1.default.wallet;
+        let event;
+        let maxTimeout = 20000;
+        do {
+            event = await db_1.Transaction.findOne({ where: { transactionHash: data.transactionHash } });
+            if (!event) {
+                await (0, waait_1.default)(1000);
+                maxTimeout -= 1000;
+            }
+        } while (!event && maxTimeout > 0);
+        if (!event) {
+            return {
+                signer: signer.address,
+                data: null,
+                error: 'Event not found'
+            };
+        }
+        // const signedData = await signGnosisSafeTx({
+        //     to: addresses[event.chainId as ChainId].multisend,
+        //     data: 'TODO',
+        //     chainId: event.chainId as ChainId,
+        //     safeTxGas: data.safeTxGas,
+        // }, { signer });
+        return {
+            signer: signer.address,
+            data: null, //signedData,
+        };
+    }
+}
+exports.SignatureDialProtocol = SignatureDialProtocol;

package/dist/net/protocol/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocol = void 0;
+const stream_1 = require("stream");
+const ethereumjs_util_1 = require("ethereumjs-util");
+const SignatureDialProtocol_1 = require("./dial/SignatureDialProtocol");
+const __1 = require("..");
+const config_1 = __importDefault(require("@/config"));
+const types_1 = require("@/types");
+class Protocol extends stream_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.protocolMessages = [
+            {
+                name: 'PeerInfo',
+                code: 0x09,
+                encode: (info) => [
+                    Buffer.from(info.publicAddress),
+                ],
+                decode: ([publicAddress]) => ({
+                    publicAddress: publicAddress.toString(),
+                }),
+            },
+        ];
+    }
+    start({ libp2p, topic = null, }) {
+        this.libp2p = libp2p;
+        this.topic = topic || 'itnerop-x-protocol';
+        if (this.libp2p.isStarted())
+            this.init();
+        this.on('PeerInfo', (payload) => {
+            config_1.default.events.emit(types_1.Event.PEER_CONNECTED, {
+                id: payload.peerId,
+                publicAddress: payload.data.publicAddress,
+                pooled: false,
+                updated: new Date(),
+            });
+        });
+        this.signature = new SignatureDialProtocol_1.SignatureDialProtocol(this.libp2p);
+    }
+    init() {
+        this.libp2p.pubsub.subscribe(this.topic);
+        this.libp2p.pubsub.on(this.topic, (message) => {
+            try {
+                const [codeBuf, payload] = ethereumjs_util_1.rlp.decode(message.data);
+                const code = (0, ethereumjs_util_1.bufferToInt)(codeBuf);
+                const protocolMessage = this.protocolMessages.find((m) => m.code === code);
+                if (!protocolMessage) {
+                    return;
+                }
+                const decoded = protocolMessage.decode(payload);
+                this.emit(protocolMessage.name, {
+                    peerId: message.from,
+                    name: protocolMessage.name,
+                    code: protocolMessage.code,
+                    data: decoded
+                });
+                this.emit('all', {
+                    peerId: message.from,
+                    name: protocolMessage.name,
+                    code: protocolMessage.code,
+                    data: decoded,
+                });
+            }
+            catch (err) {
+                console.error(err);
+            }
+        });
+    }
+    sendPeerInfo(data) {
+        const message = this.protocolMessages.find((m) => m.name === 'PeerInfo');
+        const encoded = ethereumjs_util_1.rlp.encode([message.code, message.encode(data)]);
+        this.libp2p.pubsub.publish(this.topic, encoded);
+    }
+    async requestSignatures(data, peerIds) {
+        try {
+            peerIds = peerIds || __1.peerPool.activePeerIds;
+            const promises = peerIds.map((peerId) => this.signature.send(data, peerId));
+            return (await Promise.allSettled(promises))
+                .map((p) => p.status === 'fulfilled' ? p.value : null)
+                .filter(Boolean);
+        }
+        catch (error) {
+            console.log(error);
+            return [];
+        }
+    }
+}
+exports.protocol = new Protocol();