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

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,48 @@
+"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 utils_1 = require("../../../utils");
+const BaseDialProtocol_1 = require("./BaseDialProtocol");
+const waait_1 = __importDefault(require("waait"));
+const config_1 = __importDefault(require("config"));
+const constants_1 = require("../../../constants");
+const db_1 = require("db");
+class SignatureDialProtocol extends BaseDialProtocol_1.BaseDialProtocol {
+    constructor(libp2p) {
+        super(libp2p, '/signatures');
+        this.timeout = 30000;
+    }
+    async response(data) {
+        const signer = config_1.default.wallet;
+        let event;
+        let maxTimeout = 20000;
+        do {
+            event = await db_1.Execution.findOne({ where: { vnonce: data.vnonce.toString() } });
+            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 (0, utils_1.signGnosisSafeTx)({
+            to: constants_1.addresses[event.chainId].multisend,
+            data: 'TODO',
+            chainId: event.chainId,
+            safeTxGas: data.safeTxGas,
+        }, { signer });
+        return {
+            signer: signer.address,
+            data: 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 || '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();

package/dist/tasks/BaseTask.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTask = void 0;
+const config_1 = __importDefault(require("config"));
+const events_1 = __importDefault(require("events"));
+const waait_1 = __importDefault(require("waait"));
+const logger_1 = __importDefault(require("../logger"));
+class BaseTask extends events_1.default {
+    constructor({ logger }) {
+        super();
+        this.started = false;
+        this.pollIntervalMs = 10 * 1000;
+        this.leadNodeOnly = false;
+        this.logger = logger !== null && logger !== void 0 ? logger : new logger_1.default('BaseTask');
+    }
+    async pollCheck() {
+        while (true) {
+            if (!this.started) {
+                return;
+            }
+            try {
+                const shouldPoll = this.prePollHandler();
+                if (shouldPoll) {
+                    await this.pollHandler();
+                }
+            }
+            catch (err) {
+                this.logger.error(`poll check error: ${err.message}\ntrace: ${err.stack}`);
+            }
+            await this.postPollHandler();
+        }
+    }
+    prePollHandler() {
+        if (!this.leadNodeOnly) {
+            return true;
+        }
+        return config_1.default.isLeadNode();
+    }
+    async pollHandler() {
+        this.logger.warn('pollHandler not implemented');
+    }
+    async postPollHandler() {
+        await (0, waait_1.default)(this.pollIntervalMs);
+    }
+    async start() {
+        this.started = true;
+        try {
+            await this.pollCheck();
+        }
+        catch (err) {
+            this.logger.error(`base task error: ${err.message}\ntrace: ${err.stack}`);
+        }
+    }
+    async stop() {
+        this.started = false;
+    }
+}
+exports.BaseTask = BaseTask;

package/dist/tasks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tasks = void 0;
+class Tasks {
+    constructor() {
+        this.tasks = [];
+    }
+    async start() {
+        for (const task of this.tasks) {
+            try {
+                task.start();
+            }
+            catch (error) {
+                console.error(`Error starting task: ${task.constructor.name}`);
+            }
+        }
+    }
+}
+exports.Tasks = Tasks;

package/dist/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = exports.Event = void 0;
+const events_1 = require("events");
+/**
+ * Types for the central event bus, emitted
+ * by different components of the client.
+ */
+var Event;
+(function (Event) {
+    Event["PEER_CONNECTED"] = "peer:connected";
+    Event["PEER_DISCONNECTED"] = "peer:disconnected";
+    Event["PEER_ERROR"] = "peer:error";
+    Event["POOL_PEER_ADDED"] = "pool:peer:added";
+    Event["POOL_PEER_REMOVED"] = "pool:peer:removed";
+    Event["POOL_PEER_BANNED"] = "pool:peer:banned";
+})(Event = exports.Event || (exports.Event = {}));
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class EventBus extends events_1.EventEmitter {
+}
+exports.EventBus = EventBus;

package/dist/utils/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncCallWithTimeout = exports.buildSignatureBytes = exports.getRpcProviderUrl = exports.signGnosisSafeTx = exports.short = exports.http = void 0;
+/**
+ * @module util
+ */
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const constants_1 = require("../constants");
+exports.http = axios_1.default.create();
+(0, axios_retry_1.default)(exports.http, { retries: 3, retryDelay: axios_retry_1.default.exponentialDelay });
+function short(buffer) {
+    return buffer.toString('hex').slice(0, 8) + '...';
+}
+exports.short = short;
+const signGnosisSafeTx = async ({ to, data = null, value = '0', operation = '1', baseGas = '0', gasPrice = "0", gasToken = "0x0000000000000000000000000000000000000000", refundReceiver = "0x0000000000000000000000000000000000000000", safeTxGas = "79668", nonce = "0", chainId = 137, }, { signer }) => {
+    const gnosisSafe = constants_1.addresses[chainId].gnosisSafe;
+    const domain = {
+        verifyingContract: gnosisSafe,
+        chainId,
+    };
+    const types = {
+        SafeTx: [
+            { type: 'address', name: 'to' },
+            { type: 'uint256', name: 'value' },
+            { type: 'bytes', name: 'data' },
+            { type: 'uint8', name: 'operation' },
+            { type: 'uint256', name: 'safeTxGas' },
+            { type: 'uint256', name: 'baseGas' },
+            { type: 'uint256', name: 'gasPrice' },
+            { type: 'address', name: 'gasToken' },
+            { type: 'address', name: 'refundReceiver' },
+            { type: 'uint256', name: 'nonce' },
+        ],
+    };
+    const message = {
+        baseGas,
+        data,
+        gasPrice,
+        gasToken,
+        nonce: Number(nonce),
+        operation,
+        refundReceiver,
+        safeAddress: gnosisSafe,
+        safeTxGas: String(safeTxGas),
+        to,
+        value,
+    };
+    return await signer._signTypedData(domain, types, message);
+};
+exports.signGnosisSafeTx = signGnosisSafeTx;
+const getRpcProviderUrl = (chainId) => {
+    switch (chainId) {
+        case 1:
+            return 'https://rpc.instadapp.io/mainnet';
+        case 137:
+            return 'https://rpc.instadapp.io/polygon';
+        default:
+            throw new Error(`Unknown chainId: ${chainId}`);
+    }
+};
+exports.getRpcProviderUrl = getRpcProviderUrl;
+const buildSignatureBytes = (signatures) => {
+    signatures.sort((left, right) => left.signer.toLowerCase().localeCompare(right.signer.toLowerCase()));
+    let signatureBytes = "0x";
+    for (const sig of signatures) {
+        signatureBytes += sig.data.slice(2);
+    }
+    return signatureBytes;
+};
+exports.buildSignatureBytes = buildSignatureBytes;
+/**
+ * Call an async function with a maximum time limit (in milliseconds) for the timeout
+ *  Resolved promise for async function call, or an error if time limit reached
+ */
+const asyncCallWithTimeout = async (asyncPromise, timeout) => {
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeoutHandle = setTimeout(() => reject(new Error('Async call timeout limit reached')), timeout);
+    });
+    return Promise.race([asyncPromise, timeoutPromise]).then(result => {
+        clearTimeout(timeoutHandle);
+        return result;
+    });
+};
+exports.asyncCallWithTimeout = asyncCallWithTimeout;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@instadapp/interop-x",
+  "version": "0.0.0-dev.0ee2ee3",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=16",
+    "yarn": "^1.22.0"
+  },
+  "scripts": {
+    "start": "yarn build && node bin/interop-x",
+    "build": "export GIT_REF=$(git rev-parse --short HEAD) && rimraf ./dist && tsc -p tsconfig.json && replace-in-file '@GIT_SHORT_HASH@' $GIT_REF ./dist/src/**/*.js",
+    "dev": "NODE_ENV=development nodemon",
+    "prepublishOnly": "yarn build"
+  },
+  "nodemonConfig": {
+    "watch": [
+      "src"
+    ],
+    "ext": "ts",
+    "exec": "./node_modules/.bin/ts-node --files -r tsconfig-paths/register ./src/index.ts"
+  },
+  "dependencies": {
+    "@achingbrain/libp2p-gossipsub": "^0.12.2",
+    "axios": "^0.27.1",
+    "axios-retry": "^3.2.4",
+    "bignumber.js": "^9.0.2",
+    "chalk": "4.1.2",
+    "dotenv": "^16.0.0",
+    "ethereumjs-util": "^7.1.4",
+    "ethers": "^5.6.4",
+    "ethers-multisend": "^2.1.1",
+    "libp2p": "^0.36.2",
+    "libp2p-bootstrap": "^0.14.0",
+    "libp2p-kad-dht": "^0.28.6",
+    "libp2p-mdns": "^0.18.0",
+    "libp2p-mplex": "^0.10.7",
+    "libp2p-noise": "^4.0.0",
+    "libp2p-pubsub-peer-discovery": "^4.0.0",
+    "libp2p-tcp": "^0.17.2",
+    "libp2p-websockets": "^0.16.2",
+    "luxon": "^2.3.2",
+    "sequelize": "^6.19.0",
+    "waait": "^1.0.5"
+  },
+  "bin": {
+    "interop-node": "bin/interop-x"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^17.0.17",
+    "nodemon": "^2.0.15",
+    "replace-in-file": "^6.3.2",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.5.0",
+    "tsconfig-paths": "^3.12.0",
+    "typescript": "^4.5.5"
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,24 @@
+import { ethers, Wallet } from "ethers"
+import { EventBus, EventBusType } from "types"
+
+class Config {
+    public readonly events: EventBusType
+    public readonly maxPeers: number
+    public readonly leadNodeAddress: string
+    public readonly privateKey: string
+    public readonly wallet: Wallet
+
+    constructor() {
+        this.events = new EventBus()  as EventBusType
+        this.maxPeers = 10
+        this.privateKey = process.env.PRIVATE_KEY as string;
+        this.wallet = new Wallet(this.privateKey);
+        this.leadNodeAddress = '0x910E413DBF3F6276Fe8213fF656726bDc142E08E'
+    }
+
+    isLeadNode() {
+        return ethers.utils.getAddress(this.leadNodeAddress) === ethers.utils.getAddress(this.wallet.address)
+    }
+}
+
+export default new Config()

package/src/constants/addresses.ts

@@ -0,0 +1,10 @@
+export const addresses = {
+  1: {
+    gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
+    multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+  },
+  137: {
+    gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
+    multisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+  },
+}

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from './addresses';

package/src/db/index.ts

@@ -0,0 +1 @@
+export * from "./models"

package/src/db/models/execution.ts

@@ -0,0 +1,57 @@
+import { sequelize } from '../sequelize'
+import { CreationOptional, InferAttributes, InferCreationAttributes, Model, DataTypes } from 'sequelize';
+
+export class Execution extends Model<InferAttributes<Execution>, InferCreationAttributes<Execution>> {
+    declare id: CreationOptional<number>;
+
+    declare transactionHash: string;
+    declare from: string;
+    declare executions: any[];
+    declare chainId: number;
+    declare gas: string;
+    declare maxGasPrice: string;
+    declare assets: any[];
+    declare metadata: string;
+    declare vnonce: string;
+    declare txHash: string;
+
+    declare blockNumber: string;
+    declare status: CreationOptional<string>;
+    declare delayUntil: CreationOptional<Date>;
+    declare delayedCount: CreationOptional<number>;
+
+    declare error: CreationOptional<string>;
+    declare createdAt: CreationOptional<Date>;
+    declare updatedAt: CreationOptional<Date>;
+}
+
+Execution.init({
+    id: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+    },
+    transactionHash: DataTypes.STRING,
+    from: DataTypes.STRING,
+    executions: DataTypes.JSON,
+    chainId: DataTypes.NUMBER,
+    gas: DataTypes.STRING,
+    maxGasPrice: DataTypes.STRING,
+    assets: DataTypes.JSON,
+    metadata: DataTypes.STRING,
+    vnonce: DataTypes.STRING,
+    txHash: DataTypes.STRING,
+    blockNumber: DataTypes.STRING,
+    status: {
+        type: DataTypes.STRING,
+        defaultValue: 'pending'
+    },
+    delayUntil: DataTypes.DATE,
+    delayedCount: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0
+    },
+    error: DataTypes.STRING,
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+}, { sequelize, tableName: 'executions' });

package/src/db/models/index.ts

@@ -0,0 +1 @@
+export * from './execution';

package/src/db/sequelize.ts

@@ -0,0 +1,21 @@
+//@ts-ignore
+import expandHomeDir from "expand-home-dir";
+
+import { Sequelize } from 'sequelize';
+
+const basePath = expandHomeDir('~/.interop-x/data');
+
+export const sequelize = new Sequelize({
+    dialect: 'sqlite',
+    storage: `${basePath}/localDB.sqlite`,
+    // dialectModulePath: '@journeyapps/sqlcipher',
+    logging: false,
+});
+
+sequelize.sync({
+    alter: true
+}).then(() => {
+    //     sequelize.query('PRAGMA cipher_compatibility = 3');
+    //     sequelize.query("PRAGMA key = 'your-encryption-key'");
+})
+

package/src/index.ts

@@ -0,0 +1,39 @@
+import { assert } from "console";
+import dotenv from "dotenv";
+import { Tasks } from "tasks";
+import Logger from "./logger";
+import { startPeer } from "./net";
+dotenv.config();
+
+assert(process.env.PRIVATE_KEY, "PRIVATE_KEY is not defined");
+
+const logger = new Logger('Process')
+
+async function main() {
+
+    startPeer({})
+
+    const tasks = new 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: Error, p: Promise<any>) => {
+    logger.error('unhandled rejection: promise:', p, 'reason:', reason)
+})