@gainsnetwork/sdk 0.0.23-rc1 → 0.0.23-rc3

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

@@ -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/utils/packing.d.ts

@@ -1,2 +1,2 @@
-export declare const pack64To256: (x: bigint, y: bigint, z: bigint, w: bigint) => bigint;
-export declare const unpack256To64: (packed: bigint) => [bigint, bigint, bigint, bigint];
+export declare const pack: (values: bigint[], bitLengths: bigint[]) => bigint;
+export declare const unpack: (packed: bigint, bitLengths: bigint[]) => bigint[];

package/lib/utils/packing.js

@@ -1,20 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unpack256To64 = exports.pack64To256 = void 0;
-const pack64To256 = (x, y, z, w) => {
+exports.unpack = exports.pack = void 0;
+const pack = (values, bitLengths) => {
+    if (values.length !== bitLengths.length) {
+        throw new Error("Mismatch in the lengths of values and bitLengths arrays");
+    }
     let packed = BigInt(0);
-    packed |= x;
-    packed |= y << BigInt(34);
-    packed |= z << BigInt(68);
-    packed |= w << BigInt(102);
+    let currentShift = BigInt(0);
+    for (let i = 0; i < values.length; i++) {
+        if (currentShift + bitLengths[i] > BigInt(256)) {
+            throw new Error("Packed value exceeds 256 bits");
+        }
+        const maxValue = (BigInt(1) << bitLengths[i]) - BigInt(1);
+        if (values[i] > maxValue) {
+            throw new Error("Value too large for specified bit length");
+        }
+        const maskedValue = values[i] & maxValue;
+        packed |= maskedValue << currentShift;
+        currentShift += bitLengths[i];
+    }
     return packed;
 };
-exports.pack64To256 = pack64To256;
-const unpack256To64 = (packed) => {
-    const x = packed & BigInt("0x3FFFFFFFF");
-    const y = (packed >> BigInt(34)) & BigInt("0x3FFFFFFFF");
-    const z = (packed >> BigInt(68)) & BigInt("0x3FFFFFFFF");
-    const w = (packed >> BigInt(102)) & BigInt("0x3FFFFFFFF");
-    return [x, y, z, w];
+exports.pack = pack;
+const unpack = (packed, bitLengths) => {
+    const values = [];
+    let currentShift = BigInt(0);
+    for (let i = 0; i < bitLengths.length; i++) {
+        if (currentShift + bitLengths[i] > BigInt(256)) {
+            throw new Error("Unpacked value exceeds 256 bits");
+        }
+        const maxValue = (BigInt(1) << bitLengths[i]) - BigInt(1);
+        const mask = maxValue << currentShift;
+        values[i] = (packed & mask) >> currentShift;
+        currentShift += bitLengths[i];
+    }
+    return values;
 };
-exports.unpack256To64 = unpack256To64;
+exports.unpack = unpack;

package/package.json

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