@polymarket/relayer-client 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,21 @@
+import { Wallet } from "@ethersproject/wallet";
+import { JsonRpcSigner } from "@ethersproject/providers";
+import { AddressPayload, AuthArgs, NoncePayload, ProxyTransaction, RelayPayload, SafeTransaction } from "./types";
+export declare class RelayClient {
+    readonly relayerUrl: string;
+    readonly chainId: number;
+    readonly signer?: Wallet | JsonRpcSigner;
+    readonly wsRelayerUrl?: string;
+    private authHandler;
+    constructor(relayerUrl: string, chainId: number, authArgs: AuthArgs, signer?: Wallet | JsonRpcSigner, wsRelayerUrl?: string);
+    getOk(): Promise<any>;
+    getRelayAddress(): Promise<AddressPayload>;
+    getNonce(signerAddress: string, signerType: string): Promise<NoncePayload>;
+    getRelayPayload(signerAddress: string, signerType: string): Promise<RelayPayload>;
+    getTransaction(transactionId: string): Promise<RelayPayload>;
+    executeProxyTransactions(txns: ProxyTransaction[]): Promise<any>;
+    executeSafeTransactions(txns: SafeTransaction[]): Promise<any>;
+    deploySafe(): Promise<any>;
+    initializeWsConnection(transactionId?: string): Promise<void>;
+    private sendTransactionRequest;
+}

package/dist/client.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayClient = void 0;
+const tslib_1 = require("tslib");
+const ethers_1 = require("ethers");
+const ws_1 = require("ws");
+const http_helpers_1 = require("./http-helpers");
+const types_1 = require("./types");
+const endpoints_1 = require("./endpoints");
+const builder_1 = require("./builder");
+const encode_1 = require("./encode");
+const create_1 = require("./builder/create");
+const auth_1 = require("./auth");
+class RelayClient {
+    constructor(relayerUrl, chainId, authArgs, signer, wsRelayerUrl) {
+        this.relayerUrl = relayerUrl.endsWith("/") ? relayerUrl.slice(0, -1) : relayerUrl;
+        this.chainId = chainId;
+        this.authHandler = new auth_1.AuthHandler(authArgs);
+        if (signer !== undefined) {
+            this.signer = signer;
+            if (signer.provider == undefined) {
+                throw new Error("signer must have provider attached");
+            }
+        }
+        if (wsRelayerUrl !== undefined) {
+            this.wsRelayerUrl = wsRelayerUrl;
+        }
+    }
+    getOk() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.get(`${this.relayerUrl}/`);
+        });
+    }
+    getRelayAddress() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.get(`${this.relayerUrl}${endpoints_1.GET_ADDRESS}`, { headers: yield this.authHandler.getAuthHeader() });
+        });
+    }
+    getNonce(signerAddress, signerType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.get(`${this.relayerUrl}${endpoints_1.GET_NONCE}?address=${signerAddress}&type=${signerType}`, { headers: yield this.authHandler.getAuthHeader() });
+        });
+    }
+    getRelayPayload(signerAddress, signerType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.get(`${this.relayerUrl}${endpoints_1.GET_RELAY_PAYLOAD}?address=${signerAddress}&type=${signerType}`, { headers: yield this.authHandler.getAuthHeader() });
+        });
+    }
+    getTransaction(transactionId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.get(`${this.relayerUrl}${endpoints_1.GET_TRANSACTION}?id=${transactionId}`, { headers: yield this.authHandler.getAuthHeader() });
+        });
+    }
+    executeProxyTransactions(txns) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.signer == undefined) {
+                throw new Error("missing signer");
+            }
+            const start = Date.now();
+            const from = yield this.signer.getAddress();
+            const rp = yield this.getRelayPayload(from, types_1.TransactionType.PROXY);
+            const args = {
+                from: from,
+                gasPrice: "0",
+                data: encode_1.encodeProxyTransactionData(txns),
+                relay: rp.address,
+                nonce: rp.nonce,
+            };
+            const request = yield builder_1.buildProxyTransactionRequest(this.signer, args);
+            console.log(`Client side request creation took: ${(Date.now() - start) / 1000} seconds`);
+            return this.sendTransactionRequest(request);
+        });
+    }
+    executeSafeTransactions(txns) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.signer == undefined) {
+                throw new Error("missing signer");
+            }
+            const start = Date.now();
+            const from = yield this.signer.getAddress();
+            // Note: goes over the network
+            const noncePayload = yield this.getNonce(from, types_1.TransactionType.SAFE);
+            const args = {
+                transactions: txns,
+                from,
+                nonce: noncePayload.nonce,
+                chainId: this.chainId,
+            };
+            const request = yield builder_1.buildSafeTransactionRequest(this.signer, args);
+            console.log(`Client side request creation took: ${(Date.now() - start) / 1000} seconds`);
+            return this.sendTransactionRequest(request);
+        });
+    }
+    deploySafe() {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.signer == undefined) {
+                throw new Error("missing signer");
+            }
+            const start = Date.now();
+            const from = yield ((_a = this.signer) === null || _a === void 0 ? void 0 : _a.getAddress());
+            const args = {
+                from: from,
+                chainId: this.chainId,
+                paymentToken: ethers_1.ethers.constants.AddressZero,
+                payment: "0",
+                paymentReceiver: ethers_1.ethers.constants.AddressZero,
+            };
+            const request = yield create_1.buildSafeCreateTransactionRequest(this.signer, args);
+            console.log(`Client side request creation took: ${(Date.now() - start) / 1000} seconds`);
+            return this.sendTransactionRequest(request);
+        });
+    }
+    initializeWsConnection(transactionId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.signer == undefined) {
+                throw new Error("missing signer");
+            }
+            if (this.wsRelayerUrl == undefined) {
+                throw new Error("missing websocket url");
+            }
+            const from = yield this.signer.getAddress();
+            const txns = [];
+            if (transactionId !== undefined) {
+                txns.push(transactionId);
+            }
+            const authCookies = yield this.authHandler.getPolymarketCookies();
+            const req = {
+                address: from,
+                transactions: txns,
+                cookies: authCookies,
+            };
+            const ws = new ws_1.WebSocket(`${this.wsRelayerUrl}${endpoints_1.WS_CONNECTION}`);
+            ws.on("open", function () {
+                ws.send(JSON.stringify(req));
+                setInterval(() => {
+                    ws.send("PING");
+                }, 5000);
+            });
+            ws.onmessage = function (msg) {
+                console.log(`Received ws message:`);
+                console.log(msg.data);
+            };
+            ws.on("close", function (e) {
+                console.log("WS Connection closed, reason: " + e);
+                return;
+            });
+        });
+    }
+    sendTransactionRequest(req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return http_helpers_1.post(`${this.relayerUrl}${endpoints_1.SUBMIT_TRANSACTION}`, {
+                data: req,
+                headers: yield this.authHandler.getAuthHeader()
+            });
+        });
+    }
+}
+exports.RelayClient = RelayClient;

package/dist/constants/index.d.ts

@@ -0,0 +1,6 @@
+export declare const RELAY_HUB_ADDRESS = "0xD216153c06E857cD7f72665E0aF1d7D82172F494";
+export declare const PROXY_WALLET_FACTORY_ADDRESS = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052";
+export declare const SAFE_FACTORY_ADDRESS = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b";
+export declare const SAFE_MULTISEND_ADDRESS = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761";
+export declare const SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+export declare const SAFE_FACTORY_NAME = "Polymarket Contract Proxy Factory";

package/dist/constants/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFE_FACTORY_NAME = exports.SAFE_INIT_CODE_HASH = exports.SAFE_MULTISEND_ADDRESS = exports.SAFE_FACTORY_ADDRESS = exports.PROXY_WALLET_FACTORY_ADDRESS = exports.RELAY_HUB_ADDRESS = void 0;
+exports.RELAY_HUB_ADDRESS = "0xD216153c06E857cD7f72665E0aF1d7D82172F494";
+exports.PROXY_WALLET_FACTORY_ADDRESS = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052";
+exports.SAFE_FACTORY_ADDRESS = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b";
+exports.SAFE_MULTISEND_ADDRESS = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761";
+exports.SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+exports.SAFE_FACTORY_NAME = "Polymarket Contract Proxy Factory";

package/dist/encode/index.d.ts

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

package/dist/encode/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./proxy"), exports);

package/dist/encode/proxy.d.ts

@@ -0,0 +1,2 @@
+import { ProxyTransaction } from "../types";
+export declare const encodeProxyTransactionData: (txns: ProxyTransaction[]) => string;

package/dist/encode/proxy.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeProxyTransactionData = void 0;
+const utils_1 = require("ethers/lib/utils");
+const abis_1 = require("../abis");
+const factoryInterface = new utils_1.Interface(abis_1.proxyWalletFactory);
+exports.encodeProxyTransactionData = (txns) => {
+    return factoryInterface.encodeFunctionData("proxy((uint8,address,uint256,bytes)[])", [txns]);
+};

package/dist/encode/safe.d.ts

@@ -0,0 +1,2 @@
+import { SafeTransaction } from "../types";
+export declare const createSafeMultisendTransaction: (txns: SafeTransaction[]) => SafeTransaction;

package/dist/encode/safe.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSafeMultisendTransaction = void 0;
+const utils_1 = require("ethers/lib/utils");
+const constants_1 = require("../constants");
+const abis_1 = require("../abis");
+const types_1 = require("../types");
+const utils_2 = require("./utils");
+const multisendInterface = new utils_1.Interface(abis_1.multisendAbi);
+exports.createSafeMultisendTransaction = (txns) => {
+    const data = multisendInterface.encodeFunctionData("multiSend", [
+        utils_2.joinHexData(txns.map(tx => utils_2.abiEncodePacked({ type: "uint8", value: tx.operation }, { type: "address", value: tx.to }, { type: "uint256", value: tx.value }, { type: "uint256", value: utils_2.getHexDataLength(tx.data) }, { type: "bytes", value: tx.data }))),
+    ]);
+    return {
+        to: constants_1.SAFE_MULTISEND_ADDRESS,
+        value: "0",
+        data: data,
+        operation: types_1.OperationType.DelegateCall,
+    };
+};

package/dist/encode/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function joinHexData(hexData: string[]): string;
+export declare function abiEncodePacked(...params: {
+    type: string;
+    value: any;
+}[]): string;
+export declare function getHexDataLength(hexData: string): number;

package/dist/encode/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHexDataLength = exports.abiEncodePacked = exports.joinHexData = void 0;
+const abi_1 = require("@ethersproject/abi");
+function joinHexData(hexData) {
+    return `0x${hexData
+        .map((hex) => {
+        const stripped = hex.replace(/^0x/, '');
+        return stripped.length % 2 === 0 ? stripped : '0' + stripped;
+    })
+        .join('')}`;
+}
+exports.joinHexData = joinHexData;
+function abiEncodePacked(...params) {
+    return joinHexData(params.map(({ type, value }) => {
+        const encoded = abi_1.defaultAbiCoder.encode([type], [value]);
+        if (type === 'bytes' || type === 'string') {
+            const bytesLength = parseInt(encoded.slice(66, 130), 16);
+            return encoded.slice(130, 130 + 2 * bytesLength);
+        }
+        let typeMatch = type.match(/^(?:u?int\d*|bytes\d+|address)\[\]$/);
+        if (typeMatch) {
+            return encoded.slice(130);
+        }
+        if (type.startsWith('bytes')) {
+            const bytesLength = parseInt(type.slice(5));
+            return encoded.slice(2, 2 + 2 * bytesLength);
+        }
+        typeMatch = type.match(/^u?int(\d*)$/);
+        if (typeMatch) {
+            if (typeMatch[1] !== '') {
+                const bytesLength = parseInt(typeMatch[1]) / 8;
+                return encoded.slice(-2 * bytesLength);
+            }
+            return encoded.slice(-64);
+        }
+        if (type === 'address') {
+            return encoded.slice(-40);
+        }
+        throw new Error(`unsupported type ${type}`);
+    }));
+}
+exports.abiEncodePacked = abiEncodePacked;
+function getHexDataLength(hexData) {
+    return Math.ceil((hexData.startsWith("0x") ? hexData.length - 2 : hexData.length) / 2);
+}
+exports.getHexDataLength = getHexDataLength;

package/dist/endpoints.d.ts

@@ -0,0 +1,6 @@
+export declare const GET_ADDRESS = "/address";
+export declare const GET_NONCE = "/nonce";
+export declare const GET_RELAY_PAYLOAD = "/relay-payload";
+export declare const GET_TRANSACTION = "/transaction";
+export declare const SUBMIT_TRANSACTION = "/submit";
+export declare const WS_CONNECTION = "/ws";

package/dist/endpoints.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_CONNECTION = exports.SUBMIT_TRANSACTION = exports.GET_TRANSACTION = exports.GET_RELAY_PAYLOAD = exports.GET_NONCE = exports.GET_ADDRESS = void 0;
+exports.GET_ADDRESS = "/address";
+exports.GET_NONCE = "/nonce";
+exports.GET_RELAY_PAYLOAD = "/relay-payload";
+exports.GET_TRANSACTION = "/transaction";
+exports.SUBMIT_TRANSACTION = "/submit";
+exports.WS_CONNECTION = "/ws";

package/dist/http-helpers/index.d.ts

@@ -0,0 +1,16 @@
+import { AxiosRequestHeaders, Method } from "axios";
+export declare const GET = "GET";
+export declare const POST = "POST";
+export declare const DELETE = "DELETE";
+export declare const PUT = "PUT";
+export declare const request: (endpoint: string, method: Method, headers?: any, data?: any, params?: any) => Promise<any>;
+export declare type QueryParams = Record<string, any>;
+export interface RequestOptions {
+    headers?: AxiosRequestHeaders;
+    data?: any;
+    params?: QueryParams;
+}
+export declare const post: (endpoint: string, options?: RequestOptions | undefined) => Promise<any>;
+export declare const raw_get: (endpoint: string, options?: RequestOptions | undefined) => Promise<any>;
+export declare const get: (endpoint: string, options?: RequestOptions | undefined) => Promise<any>;
+export declare const del: (endpoint: string, options?: RequestOptions | undefined) => Promise<any>;

package/dist/http-helpers/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.del = exports.get = exports.raw_get = exports.post = exports.request = exports.PUT = exports.DELETE = exports.POST = exports.GET = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+exports.GET = "GET";
+exports.POST = "POST";
+exports.DELETE = "DELETE";
+exports.PUT = "PUT";
+exports.request = (endpoint, method, headers, data, params) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    try {
+        const response = yield axios_1.default({ method, url: endpoint, headers, data, params });
+        return response;
+    }
+    catch (err) {
+        if (axios_1.default.isAxiosError(err)) {
+            if (err.response) {
+                console.error("request error", {
+                    error: "request error",
+                    status: (_a = err.response) === null || _a === void 0 ? void 0 : _a.status,
+                    statusText: (_b = err.response) === null || _b === void 0 ? void 0 : _b.statusText,
+                    data: (_c = err.response) === null || _c === void 0 ? void 0 : _c.data,
+                });
+                return (_d = err.response) === null || _d === void 0 ? void 0 : _d.data;
+            }
+            else {
+                return { error: "connection error" };
+            }
+        }
+        return { error: err };
+    }
+});
+exports.post = (endpoint, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const resp = yield exports.request(endpoint, exports.POST, options === null || options === void 0 ? void 0 : options.headers, options === null || options === void 0 ? void 0 : options.data, options === null || options === void 0 ? void 0 : options.params);
+    if ("error" in resp) {
+        throw new Error(resp);
+    }
+    return resp.data;
+});
+exports.raw_get = (endpoint, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const resp = yield exports.request(endpoint, exports.GET, options === null || options === void 0 ? void 0 : options.headers, options === null || options === void 0 ? void 0 : options.data, options === null || options === void 0 ? void 0 : options.params);
+    if ("error" in resp) {
+        throw new Error(resp);
+    }
+    return resp;
+});
+exports.get = (endpoint, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const resp = yield exports.raw_get(endpoint, options);
+    return resp.data;
+});
+exports.del = (endpoint, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const resp = yield exports.request(endpoint, exports.DELETE, options === null || options === void 0 ? void 0 : options.headers, options === null || options === void 0 ? void 0 : options.data, options === null || options === void 0 ? void 0 : options.params);
+    if ("error" in resp) {
+        throw new Error(resp);
+    }
+    return resp.data;
+});

package/dist/main.d.ts

@@ -0,0 +1 @@
+declare function main(): Promise<void>;

package/dist/main.js

@@ -0,0 +1,17 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`Started...`);
+        console.log(`Done!`);
+    });
+}
+main();

package/dist/types.d.ts

@@ -0,0 +1,92 @@
+export declare enum TransactionType {
+    PROXY = "PROXY",
+    SAFE = "SAFE",
+    SAFE_CREATE = "SAFE-CREATE"
+}
+export interface SignatureParams {
+    gasPrice?: string;
+    relayerFee?: string;
+    gasLimit?: string;
+    relayHub?: string;
+    relay?: string;
+    operation?: string;
+    safeTxnGas?: string;
+    baseGas?: string;
+    gasToken?: string;
+    refundReceiver?: string;
+    paymentToken?: string;
+    payment?: string;
+    paymentReceiver?: string;
+}
+export interface AddressPayload {
+    address: string;
+}
+export interface NoncePayload {
+    nonce: string;
+}
+export interface RelayPayload {
+    address: string;
+    nonce: string;
+}
+export interface TransactionRequest {
+    type: string;
+    from: string;
+    to: string;
+    proxyWallet?: string;
+    data: string;
+    nonce?: string;
+    signature: string;
+    signatureParams: SignatureParams;
+    metadata?: string;
+}
+export declare enum CallType {
+    Invalid = "0",
+    Call = "1",
+    DelegateCall = "2"
+}
+export interface ProxyTransaction {
+    to: string;
+    typeCode: CallType;
+    data: string;
+    value: string;
+}
+export declare enum OperationType {
+    Call = 0,
+    DelegateCall = 1
+}
+export interface SafeTransaction {
+    to: string;
+    operation: OperationType;
+    data: string;
+    value: string;
+}
+export interface ProxyTransactionArgs {
+    from: string;
+    nonce: string;
+    gasPrice: string;
+    data: string;
+    relay: string;
+}
+export interface SafeTransactionArgs {
+    from: string;
+    nonce: string;
+    chainId: number;
+    transactions: SafeTransaction[];
+}
+export interface SafeCreateTransactionArgs {
+    from: string;
+    chainId: number;
+    paymentToken: string;
+    payment: string;
+    paymentReceiver: string;
+}
+export interface RelayerSubRequest {
+    address: string;
+    transactions: string[];
+    cookies?: string;
+}
+export interface AuthArgs {
+    authUrl: string;
+    token?: string;
+    cookie?: string;
+}

package/dist/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationType = exports.CallType = exports.TransactionType = void 0;
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["PROXY"] = "PROXY";
+    TransactionType["SAFE"] = "SAFE";
+    TransactionType["SAFE_CREATE"] = "SAFE-CREATE";
+})(TransactionType = exports.TransactionType || (exports.TransactionType = {}));
+var CallType;
+(function (CallType) {
+    CallType["Invalid"] = "0";
+    CallType["Call"] = "1";
+    CallType["DelegateCall"] = "2";
+})(CallType = exports.CallType || (exports.CallType = {}));
+// Safe Transactions
+var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["Call"] = 0] = "Call";
+    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
+})(OperationType = exports.OperationType || (exports.OperationType = {}));

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@polymarket/relayer-client",
+    "description": "Client for Polymarket relayers",
+    "version": "0.0.1",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "/dist"
+    ],
+    "scripts": {
+        "build": "yarn clean && tsc --project tsconfig.production.json",
+        "clean": "rm -rf ./dist"
+    },
+    "dependencies": {
+        "@polymarket/sdk": "^5.0.3",
+        "axios": "^0.27.2",
+        "ethers": "^5.7.1"
+    },
+    "devDependencies": {
+        "@types/chai": "^4.3.3",
+        "@types/mocha": "^9.1.1",
+        "@types/node": "^18.7.18",
+        "@types/ws": "^8.5.3",
+        "@typescript-eslint/eslint-plugin": "^5.37.0",
+        "@typescript-eslint/parser": "^5.37.0",
+        "chai": "^4.3.6",
+        "eslint": "^8.23.1",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-config-standard-with-typescript": "^23.0.0",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-n": "^15.2.5",
+        "eslint-plugin-node": "^11.1.0",
+        "eslint-plugin-promise": "^6.0.1",
+        "eslint-plugin-unused-imports": "^2.0.0",
+        "esm": "^3.2.25",
+        "dotenv": "^16.0.2",
+        "path": "^0.12.7",
+        "mocha": "^10.0.0",
+        "nyc": "^15.1.0",
+        "prettier": "^2.7.1",
+        "ts-mocha": "^10.0.0",
+        "ts-node": "^9.1.1",
+        "typescript": "^3.9.7",
+        "web3-utils": "^1.3.5",
+        "ws": "^8.11.0"
+    }
+}