@gainsnetwork/sdk 0.0.19 → 0.0.20-rc2

package/lib/prices/PricingNetworkClient.js

@@ -0,0 +1,179 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingNetworkClient = void 0;
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const ws_1 = __importDefault(require("ws"));
+const __1 = require("..");
+class PricingNetworkClient {
+    constructor(endpoints, onPriceMessage, concurrentConnections = 3, bufferTimeoutMs = 500, reconnectTimeoutMs = 1000) {
+        this.endpoints = endpoints;
+        this._onPriceMessage = onPriceMessage;
+        this.concurrentConnections = concurrentConnections;
+        this.bufferTimeoutMs = bufferTimeoutMs;
+        this.reconnectTimeoutMs = reconnectTimeoutMs;
+        this.sockets = new Map();
+        this.latencyMap = new Map();
+        this.priceBuffer = new Map();
+        this.priceBufferLastFlush = new Map();
+        this.stagedPrices = [];
+        this.pairsToIndex = new Map();
+        Object.keys(__1.pairs).forEach((pair, index) => {
+            this.pairsToIndex.set(pair, index);
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sockets.size > 0) {
+                return;
+            }
+            const latencies = yield Promise.all(this.endpoints.map(endpoint => this.measureLatency(endpoint)));
+            this.endpoints.forEach((endpoint, index) => this.latencyMap.set(endpoint, latencies[index]));
+            this.latencyMap.forEach((latency, endpoint) => console.log(`Latency to ${endpoint}: ${latency}ms`));
+            // Sort endpoints by latency
+            const sortedEndpoints = [...this.endpoints].sort((a, b) => {
+                const aLatency = latencies[this.endpoints.indexOf(a)];
+                const bLatency = latencies[this.endpoints.indexOf(b)];
+                return aLatency - bLatency;
+            });
+            for (let i = 0; i < this.concurrentConnections; i++) {
+                if (sortedEndpoints[i])
+                    this._connect(sortedEndpoints[i]);
+            }
+            // Backstop to flush the buffer in case we don't get any messages
+            setInterval(() => {
+                const now = Date.now();
+                this.priceBuffer.forEach((buffer, pair) => {
+                    const lastFlush = this.priceBufferLastFlush.get(pair);
+                    if (buffer.length > 0 &&
+                        lastFlush &&
+                        now - lastFlush > this.bufferTimeoutMs) {
+                        const median = buffer.sort()[Math.floor(buffer.length / 2)];
+                        this.stagedPrices.push(pair, median);
+                        buffer.length = 0;
+                    }
+                });
+            }, this.bufferTimeoutMs);
+        });
+    }
+    _connect(endpoint) {
+        const socket = new ws_1.default(endpoint);
+        this.sockets.set(endpoint, socket);
+        socket.onmessage = message => {
+            // Ignore return pong messages
+            if (message.data === "pong") {
+                return;
+            }
+            this.processMessage(message);
+        };
+        socket.onclose = () => {
+            this.sockets.delete(endpoint);
+            setTimeout(() => {
+                this.fallbackToNextEndpoint();
+            }, this.reconnectTimeoutMs);
+        };
+        socket.onerror = error => {
+            console.error(`WebSocket error: ${error.message}`);
+        };
+    }
+    fallbackToNextEndpoint() {
+        const connectedEndpoints = [...this.sockets.keys()];
+        const sortedAvailableEndpoints = [...this.endpoints]
+            .sort((a, b) => {
+            const aLatency = this.latencyMap.get(a) || Number.MAX_VALUE;
+            const bLatency = this.latencyMap.get(b) || Number.MAX_VALUE;
+            return aLatency - bLatency;
+        })
+            .filter(endpoint => !connectedEndpoints.includes(endpoint));
+        if (sortedAvailableEndpoints.length > 0) {
+            this._connect(sortedAvailableEndpoints[0]);
+        }
+    }
+    measureLatency(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                const startTime = Date.now();
+                const socket = new ws_1.default(endpoint);
+                socket.onopen = () => {
+                    socket.send("ping");
+                };
+                socket.onmessage = message => {
+                    if (message.data === "pong") {
+                        const latency = Date.now() - startTime;
+                        socket.close();
+                        resolve(latency);
+                    }
+                };
+                socket.on("error", e => {
+                    resolve(Number.MAX_VALUE);
+                });
+                // Backstop so we don't wait forever
+                setTimeout(() => {
+                    socket.close();
+                    resolve(2000);
+                }, 2000);
+            });
+        });
+    }
+    processMessage(message) {
+        var _a;
+        try {
+            const priceUpdates = JSON.parse(message.data.toString());
+            if (!priceUpdates) {
+                console.log("Invalid price update message received", priceUpdates);
+                return;
+            }
+            const finalMessage = [];
+            for (let i = 0; i < priceUpdates.length; i += 1) {
+                const pairAndPrice = priceUpdates[i];
+                const pair = this.pairsToIndex.get(pairAndPrice[0]);
+                if (pair === undefined) {
+                    console.log("Invalid pair received", pairAndPrice[0]);
+                    continue;
+                }
+                const price = pairAndPrice[1];
+                if (!this.priceBuffer.has(pair)) {
+                    this.priceBuffer.set(pair, []);
+                    this.priceBufferLastFlush.set(pair, 0);
+                }
+                // Checking existence above, so this should be safe
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const buffer = this.priceBuffer.get(pair);
+                if (buffer.length >= this.sockets.size) {
+                    const median = buffer.sort()[Math.floor(buffer.length / 2)];
+                    finalMessage.push(pair, median);
+                    buffer.length = 0;
+                }
+                buffer.push(price);
+            }
+            if (finalMessage.length > 0 || this.stagedPrices.length > 0) {
+                finalMessage.push(...(this.stagedPrices || []));
+                (_a = this._onPriceMessage) === null || _a === void 0 ? void 0 : _a.call(this, finalMessage);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    get activeSockets() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this.sockets;
+    }
+    set onPriceMessage(callback) {
+        this._onPriceMessage = callback;
+    }
+}
+exports.PricingNetworkClient = PricingNetworkClient;

package/lib/prices/PricingStreamClient.d.ts

@@ -0,0 +1,16 @@
+import WebSocket from "ws";
+export type PriceMessage = WebSocket.MessageEvent;
+export declare class PricingStreamClient {
+    private endpoints;
+    private _activeSocket;
+    private fallbackIndex;
+    private reconnectTimeoutMs;
+    private _onPriceMessage;
+    constructor(endpoints: string[], onPriceMessage: (message: PriceMessage) => void, reconnectTimeoutMs?: number);
+    connect(): Promise<void>;
+    private _connect;
+    private fallbackToNextEndpoint;
+    private measureLatency;
+    get activeSocket(): WebSocket | null;
+    set onPriceMessage(callback: (message: WebSocket.MessageEvent) => void);
+}

package/lib/prices/PricingStreamClient.js

@@ -0,0 +1,101 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingStreamClient = void 0;
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const ws_1 = __importDefault(require("ws"));
+class PricingStreamClient {
+    constructor(endpoints, onPriceMessage, reconnectTimeoutMs = 1000) {
+        this.endpoints = endpoints;
+        this._activeSocket = null;
+        this.fallbackIndex = 0;
+        this.reconnectTimeoutMs = reconnectTimeoutMs;
+        this._onPriceMessage = onPriceMessage;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._activeSocket) {
+                return;
+            }
+            const latencies = yield Promise.all(this.endpoints.map(endpoint => this.measureLatency(endpoint)));
+            // Sort endpoints by latency
+            this.endpoints.sort((a, b) => {
+                const aLatency = latencies[this.endpoints.indexOf(a)];
+                const bLatency = latencies[this.endpoints.indexOf(b)];
+                return aLatency - bLatency;
+            });
+            this._connect(this.endpoints[0]);
+        });
+    }
+    _connect(endpoint) {
+        this._activeSocket = new ws_1.default(endpoint);
+        this._activeSocket.onmessage = message => {
+            var _a;
+            // Ignore return pong messages
+            if (message.data === "pong") {
+                return;
+            }
+            (_a = this._onPriceMessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
+        };
+        this._activeSocket.onclose = () => {
+            setTimeout(() => void this.fallbackToNextEndpoint(), this.reconnectTimeoutMs);
+        };
+        this._activeSocket.onerror = error => {
+            var _a;
+            console.error(`WebSocket error: ${error.message}`);
+            (_a = this._activeSocket) === null || _a === void 0 ? void 0 : _a.close();
+        };
+    }
+    fallbackToNextEndpoint() {
+        this.fallbackIndex = (this.fallbackIndex + 1) % this.endpoints.length;
+        const fallbackEndpoint = this.endpoints[this.fallbackIndex];
+        this._connect(fallbackEndpoint);
+    }
+    measureLatency(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                const startTime = Date.now();
+                const socket = new ws_1.default(endpoint);
+                socket.onopen = () => {
+                    socket.send("ping");
+                };
+                socket.onmessage = message => {
+                    if (message.data === "pong") {
+                        const latency = Date.now() - startTime;
+                        socket.close();
+                        resolve(latency);
+                    }
+                };
+                socket.on("error", e => {
+                    resolve(Number.MAX_VALUE);
+                });
+                // Backstop so we don't wait forever
+                setTimeout(() => {
+                    socket.close();
+                    resolve(2000);
+                }, 2000);
+            });
+        });
+    }
+    get activeSocket() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this._activeSocket;
+    }
+    set onPriceMessage(callback) {
+        this._onPriceMessage = callback;
+    }
+}
+exports.PricingStreamClient = PricingStreamClient;

package/lib/prices/index.d.ts

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

package/lib/prices/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PricingNetworkClient"), exports);

package/lib/src/contracts/addresses.d.ts

@@ -0,0 +1,2 @@
+import { ContractAddresses } from "./types";
+export declare const getContractAddressesForChain: (chainId: number) => ContractAddresses;

package/lib/src/contracts/addresses.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractAddressesForChain = void 0;
+const addresses_json_1 = __importDefault(require("./addresses.json"));
+const getContractAddressesForChain = (chainId) => {
+    const _addresses = addresses_json_1.default;
+    if (!_addresses[chainId]) {
+        throw new Error(`Unknown chain id (${chainId}). No known contracts have been deployed on this chain.`);
+    }
+    return _addresses[chainId];
+};
+exports.getContractAddressesForChain = getContractAddressesForChain;

package/lib/src/contracts/addresses.json

@@ -0,0 +1,20 @@
+{
+    "137": {
+        "gfarmTradingStorageV5": "0xaee4d11a16B2bc65EDD6416Fb626EB404a6D65BD",
+        "gnsPairsStorageV6": "0x6e5326e944F528c243B9Ca5d14fe5C9269a8c922",
+        "gnsPairInfosV6_1": "0xEe7442aCcC1C27f2C69423576d3b1D25b563E977",
+        "gTokenOpenPnlFeed": "0x8d687276543b92819F2f2B5C3faad4AD27F4440c"
+    },
+    "42161": {
+        "gfarmTradingStorageV5": "0xcFa6ebD475d89dB04cAd5A756fff1cb2BC5bE33c",
+        "gnsPairsStorageV6": "0xf67Df2a4339eC1591615d94599081Dd037960d4b",
+        "gnsPairInfosV6_1": "0x04a5e3cf21B0080B72fAcDca634349A56982D497",
+        "gTokenOpenPnlFeed": "0x990BA9Edd8a9615A23E4c452E63A80e519A4a23D"
+    },
+    "80001": {
+        "gfarmTradingStorageV5": "0x4d2dF485c608aa55A23d8d98dD2B4FA24Ba0f2Cf",
+        "gnsPairsStorageV6": "0xF7F324bc1D659f01A9a8d00C40d65568b25b4007",
+        "gnsPairInfosV6_1": "0xe780bBf94b0257fEDccF4EAEcBC70722E6F5F574",
+        "gTokenOpenPnlFeed": "0xA7C829CB2346E12DC49Fd5ea8002Abaf48E9396C"
+    }
+}

package/lib/src/contracts/index.d.ts

@@ -0,0 +1,6 @@
+import type { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import { Contracts } from "./types";
+export declare const getContractsForChain: (chainId: number, signerOrProvider?: Signer | Provider) => Contracts;
+export * from "./utils";
+export * from "./addresses";

package/lib/src/contracts/index.js

@@ -0,0 +1,31 @@
+"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 });
+exports.getContractsForChain = void 0;
+const addresses_1 = require("./addresses");
+const factories_1 = require("./types/generated/factories");
+const getContractsForChain = (chainId, signerOrProvider) => {
+    const addresses = (0, addresses_1.getContractAddressesForChain)(chainId);
+    return {
+        gfarmTradingStorageV5: factories_1.GFarmTradingStorageV5__factory.connect(addresses.gfarmTradingStorageV5, signerOrProvider),
+        gnsPairInfosV6_1: factories_1.GNSPairInfosV6_1__factory.connect(addresses.gnsPairInfosV6_1, signerOrProvider),
+        gnsPairsStorageV6: factories_1.GNSPairsStorageV6__factory.connect(addresses.gnsPairsStorageV6, signerOrProvider),
+        gTokenOpenPnlFeed: factories_1.GTokenOpenPnlFeed__factory.connect(addresses.gTokenOpenPnlFeed, signerOrProvider),
+    };
+};
+exports.getContractsForChain = getContractsForChain;
+__exportStar(require("./utils"), exports);
+__exportStar(require("./addresses"), exports);