@gainsnetwork/sdk 0.0.20-rc1 → 0.0.20-rc2

package/lib/prices/PricingNetworkClient.d.ts

@@ -0,0 +1,22 @@
+import WebSocket from "ws";
+export declare class PricingNetworkClient {
+    private endpoints;
+    private _onPriceMessage;
+    private concurrentConnections;
+    private bufferTimeoutMs;
+    private reconnectTimeoutMs;
+    private sockets;
+    private latencyMap;
+    private priceBuffer;
+    private priceBufferLastFlush;
+    private stagedPrices;
+    private pairsToIndex;
+    constructor(endpoints: string[], onPriceMessage: (prices: number[]) => void, concurrentConnections?: number, bufferTimeoutMs?: number, reconnectTimeoutMs?: number);
+    connect(): Promise<void>;
+    private _connect;
+    private fallbackToNextEndpoint;
+    private measureLatency;
+    private processMessage;
+    get activeSockets(): Map<string, WebSocket>;
+    set onPriceMessage(callback: (prices: number[]) => void);
+}

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/index.d.ts

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

package/lib/prices/index.js

@@ -14,4 +14,4 @@ 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("./PricingStreamClient"), exports);
+__exportStar(require("./PricingNetworkClient"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.0.20-rc1",
+  "version": "0.0.20-rc2",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [