@pythnetwork/pyth-lazer-sdk 5.0.0 → 5.2.1

package/dist/cjs/socket/{resilient-websocket.js → resilient-websocket.cjs}

@@ -1,13 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResilientWebSocket = void 0;
-const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
-const ts_log_1 = require("ts-log");
-const protocol_js_1 = require("../protocol.js");
-const env_util_js_1 = require("../util/env-util.js");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ResilientWebSocket", {
+    enumerable: true,
+    get: function() {
+        return ResilientWebSocket;
+    }
+});
+const _isomorphicws = /*#__PURE__*/ _interop_require_default(require("isomorphic-ws"));
+const _tslog = require("ts-log");
+const _protocol = require("../protocol.cjs");
+const _envutil = require("../util/env-util.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS = 5000; // 5 seconds
 const DEFAULT_MAX_RETRY_DELAY_MS = 1000; // 1 second'
 const DEFAULT_LOG_AFTER_RETRY_COUNT = 10;
@@ -28,7 +37,7 @@ class ResilientWebSocket {
         return this._isReconnecting;
     }
     isConnected() {
-        return this.wsClient?.readyState === isomorphic_ws_1.default.OPEN;
+        return this.wsClient?.readyState === _isomorphicws.default.OPEN;
     }
     shouldLogRetry() {
         return this.wsFailedAttempts % this.logAfterRetryCount === 0;
@@ -36,33 +45,29 @@ class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
-    constructor(config) {
+    constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
-        this.logger = config.logger ?? ts_log_1.dummyLogger;
-        this.heartbeatTimeoutDurationMs =
-            config.heartbeatTimeoutDurationMs ??
-                DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
+        this.logger = config.logger ?? _tslog.dummyLogger;
+        this.heartbeatTimeoutDurationMs = config.heartbeatTimeoutDurationMs ?? DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
         this.maxRetryDelayMs = config.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-        this.logAfterRetryCount =
-            config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
+        this.logAfterRetryCount = config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
         this.wsFailedAttempts = 0;
-        this.onError = (error) => {
+        this.onError = (error)=>{
             void error;
         };
-        this.onMessage = (data) => {
+        this.onMessage = (data)=>{
             void data;
         };
-        this.onReconnect = () => {
-            // Empty function, can be set by the user.
+        this.onReconnect = ()=>{
+        // Empty function, can be set by the user.
         };
     }
     send(data) {
         this.logger.debug(`Sending message`);
         if (this.isConnected()) {
             this.wsClient.send(data);
-        }
-        else {
+        } else {
             this.logger.warn(`WebSocket to ${this.endpoint} is not connected. Cannot send message.`);
         }
     }
@@ -85,34 +90,33 @@ class ResilientWebSocket {
         // browser constructor supports a different 2nd argument for the constructor,
         // so we need to ensure it's not included if we're running in that environment:
         // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket#protocols
-        this.wsClient = new isomorphic_ws_1.default(this.endpoint, (0, env_util_js_1.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
-        this.wsClient.addEventListener("open", () => {
+        this.wsClient = new _isomorphicws.default(this.endpoint, (0, _envutil.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
+        this.wsClient.addEventListener("open", ()=>{
             this.logger.info("WebSocket connection established");
             this.wsFailedAttempts = 0;
             this._isReconnecting = false;
             this.resetHeartbeat();
             this.onReconnect();
         });
-        this.wsClient.addEventListener("close", (e) => {
+        this.wsClient.addEventListener("close", (e)=>{
             if (this.wsUserClosed) {
                 this.logger.info(`WebSocket connection to ${this.endpoint} closed by user`);
-            }
-            else {
+            } else {
                 if (this.shouldLogRetry()) {
                     this.logger.warn(`WebSocket connection to ${this.endpoint} closed unexpectedly: Code: ${e.code.toString()}`);
                 }
                 this.handleReconnect();
             }
         });
-        this.wsClient.addEventListener("error", (event) => {
+        this.wsClient.addEventListener("error", (event)=>{
             this.onError(event);
         });
-        this.wsClient.addEventListener("message", (event) => {
+        this.wsClient.addEventListener("message", (event)=>{
             this.resetHeartbeat();
             this.onMessage(event.data);
         });
         if ("on" in this.wsClient) {
-            this.wsClient.on("ping", () => {
+            this.wsClient.on("ping", ()=>{
                 this.logger.info("Ping received");
                 this.resetHeartbeat();
             });
@@ -122,18 +126,17 @@ class ResilientWebSocket {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        this.heartbeatTimeout = setTimeout(() => {
+        this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();
-                }
-                else {
+                } else {
                     // terminate is an implementation detail of the node-friendly
                     // https://www.npmjs.com/package/ws package, but is not a native WebSocket API,
                     // so we have to use the close method
-                    this.wsClient.close(protocol_js_1.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
+                    this.wsClient.close(_protocol.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
                 }
             }
             this.handleReconnect();
@@ -154,11 +157,9 @@ class ResilientWebSocket {
         this.wsClient = undefined;
         this._isReconnecting = true;
         if (this.shouldLogRetry()) {
-            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
-                String(this.retryDelayMs()) +
-                "ms.");
+            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " + String(this.retryDelayMs()) + "ms.");
         }
-        this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = setTimeout(()=>{
             this.startWebSocket();
         }, this.retryDelayMs());
     }
@@ -170,18 +171,16 @@ class ResilientWebSocket {
         this.wsUserClosed = true;
     }
     /**
-     * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
-     *
-     * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
-     * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
-     *
-     * @returns The calculated delay in milliseconds before the next retry.
-     */
-    retryDelayMs() {
+   * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
+   *
+   * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
+   * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
+   *
+   * @returns The calculated delay in milliseconds before the next retry.
+   */ retryDelayMs() {
         if (this.wsFailedAttempts >= 10) {
             return this.maxRetryDelayMs;
         }
         return Math.min(2 ** this.wsFailedAttempts * 10, this.maxRetryDelayMs);
     }
 }
-exports.ResilientWebSocket = ResilientWebSocket;

package/dist/cjs/socket/websocket-pool.cjs

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebSocketPool", {
+    enumerable: true,
+    get: function() {
+        return WebSocketPool;
+    }
+});
+const _ttlcache = /*#__PURE__*/ _interop_require_default(require("@isaacs/ttlcache"));
+const _tslog = require("ts-log");
+const _resilientwebsocket = require("./resilient-websocket.cjs");
+const _constants = require("../constants.cjs");
+const _index = require("../emitter/index.cjs");
+const _index1 = require("../util/index.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_NUM_CONNECTIONS = 4;
+class WebSocketPool extends _index.IsomorphicEventEmitter {
+    logger;
+    rwsPool;
+    cache;
+    subscriptions;
+    messageListeners;
+    allConnectionsDownListeners;
+    wasAllDown = true;
+    checkConnectionStatesInterval;
+    constructor(logger){
+        super(), this.logger = logger;
+        this.rwsPool = [];
+        this.cache = new _ttlcache.default({
+            ttl: 1000 * 10
+        }); // TTL of 10 seconds
+        this.subscriptions = new Map();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+        // Start monitoring connection states
+        this.checkConnectionStatesInterval = setInterval(()=>{
+            this.checkConnectionStates();
+        }, 100);
+    }
+    /**
+   * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+   * Usage semantics are similar to using a regular WebSocket client.
+   * @param urls - List of WebSocket URLs to connect to
+   * @param token - Authentication token to use for the connections
+   * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+   * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+   */ static async create(config, token, logger) {
+        const urls = config.urls ?? [
+            _constants.DEFAULT_STREAM_SERVICE_0_URL,
+            _constants.DEFAULT_STREAM_SERVICE_1_URL
+        ];
+        const log = logger ?? _tslog.dummyLogger;
+        const pool = new WebSocketPool(log);
+        const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
+        // bind a handler to capture any emitted errors and send them to the user-provided
+        // onWebSocketPoolError callback (if it is present)
+        if (typeof config.onWebSocketPoolError === "function") {
+            pool.on("error", config.onWebSocketPoolError);
+            pool.once("shutdown", ()=>{
+                // unbind all error handlers so we don't leak memory
+                pool.off("error");
+            });
+        }
+        for(let i = 0; i < numConnections; i++){
+            const baseUrl = urls[i % urls.length];
+            const isBrowser = (0, _index1.envIsBrowserOrWorker)();
+            const url = isBrowser ? (0, _index1.addAuthTokenToWebSocketUrl)(baseUrl, token) : baseUrl;
+            if (!url) {
+                throw new Error(`URLs must not be null or empty`);
+            }
+            const wsOptions = {
+                ...config.rwsConfig?.wsOptions,
+                headers: isBrowser ? undefined : {
+                    Authorization: `Bearer ${token}`
+                }
+            };
+            const rws = new _resilientwebsocket.ResilientWebSocket({
+                ...config.rwsConfig,
+                endpoint: url,
+                wsOptions,
+                logger: log
+            });
+            // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
+            // the connection and call the onReconnect callback.
+            rws.onReconnect = ()=>{
+                if (rws.wsUserClosed) {
+                    return;
+                }
+                for (const [, request] of pool.subscriptions){
+                    try {
+                        rws.send(JSON.stringify(request));
+                    } catch (error) {
+                        pool.logger.error("Failed to resend subscription on reconnect:", error);
+                    }
+                }
+            };
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const onErrorHandler = config.onWebSocketError ?? config.onError;
+            if (typeof onErrorHandler === "function") {
+                rws.onError = onErrorHandler;
+            }
+            // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
+            rws.onMessage = (data)=>{
+                pool.dedupeHandler(data).catch((error)=>{
+                    pool.emitPoolError(error, "Error in WebSocketPool dedupeHandler");
+                });
+            };
+            pool.rwsPool.push(rws);
+            rws.startWebSocket();
+        }
+        pool.logger.info(`Started WebSocketPool with ${numConnections.toString()} connections. Waiting for at least one to connect...`);
+        while(!pool.isAnyConnectionEstablished()){
+            await new Promise((resolve)=>setTimeout(resolve, 100));
+        }
+        pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
+        return pool;
+    }
+    emitPoolError(error, context) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (context) {
+            this.logger.error(context, err);
+        } else {
+            this.logger.error("WebSocketPool error", err);
+        }
+        for (const errHandler of this.getListeners("error")){
+            try {
+                errHandler(err);
+            } catch (handlerError) {
+                this.logger.error("WebSocketPool error handler threw", handlerError);
+            }
+        }
+    }
+    /**
+   * Checks for error responses in JSON messages and throws appropriate errors
+   */ handleErrorMessages(data) {
+        const message = JSON.parse(data);
+        if (message.type === "subscriptionError") {
+            throw new Error(`Error occurred for subscription ID ${String(message.subscriptionId)}: ${message.error}`);
+        } else if (message.type === "error") {
+            throw new Error(`Error: ${message.error}`);
+        }
+    }
+    async constructCacheKeyFromWebsocketData(data) {
+        if (typeof data === "string") return data;
+        const buff = await (0, _index1.bufferFromWebsocketData)(data);
+        return buff.toString("hex");
+    }
+    /**
+   * Handles incoming websocket messages by deduplicating identical messages received across
+   * multiple connections before forwarding to registered handlers
+   */ dedupeHandler = async (data)=>{
+        const cacheKey = await this.constructCacheKeyFromWebsocketData(data);
+        if (this.cache.has(cacheKey)) {
+            this.logger.debug("Dropping duplicate message");
+            return;
+        }
+        this.cache.set(cacheKey, true);
+        if (typeof data === "string") {
+            this.handleErrorMessages(data);
+        }
+        try {
+            await Promise.all(this.messageListeners.map((handler)=>handler(data)));
+        } catch (error) {
+            this.emitPoolError(error, "Error in WebSocketPool message handler");
+        }
+    };
+    sendRequest(request) {
+        for (const rws of this.rwsPool){
+            try {
+                rws.send(JSON.stringify(request));
+            } catch (error) {
+                this.emitPoolError(error, "Failed to send WebSocket request");
+            }
+        }
+    }
+    addSubscription(request) {
+        if (request.type !== "subscribe") {
+            this.emitPoolError(new Error("Request must be a subscribe request"));
+            return;
+        }
+        this.subscriptions.set(request.subscriptionId, request);
+        this.sendRequest(request);
+    }
+    removeSubscription(subscriptionId) {
+        this.subscriptions.delete(subscriptionId);
+        const request = {
+            type: "unsubscribe",
+            subscriptionId
+        };
+        this.sendRequest(request);
+    }
+    addMessageListener(handler) {
+        this.messageListeners.push(handler);
+    }
+    /**
+   * Calls the handler if all websocket connections are currently down or in reconnecting state.
+   * The connections may still try to reconnect in the background.
+   */ addAllConnectionsDownListener(handler) {
+        this.allConnectionsDownListeners.push(handler);
+    }
+    areAllConnectionsDown() {
+        return this.rwsPool.every((ws)=>!ws.isConnected() || ws.isReconnecting());
+    }
+    isAnyConnectionEstablished() {
+        return this.rwsPool.some((ws)=>ws.isConnected());
+    }
+    checkConnectionStates() {
+        const allDown = this.areAllConnectionsDown();
+        // If all connections just went down
+        if (allDown && !this.wasAllDown) {
+            this.wasAllDown = true;
+            this.logger.error("All WebSocket connections are down or reconnecting");
+            // Notify all listeners
+            for (const listener of this.allConnectionsDownListeners){
+                try {
+                    listener();
+                } catch (error) {
+                    this.emitPoolError(error, "All-connections-down listener threw");
+                }
+            }
+        }
+        // If at least one connection was restored
+        if (!allDown && this.wasAllDown) {
+            this.wasAllDown = false;
+        }
+    }
+    shutdown() {
+        for (const rws of this.rwsPool){
+            rws.closeWebSocket();
+        }
+        this.rwsPool = [];
+        this.subscriptions.clear();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+        clearInterval(this.checkConnectionStatesInterval);
+        // execute all bound shutdown handlers
+        for (const shutdownHandler of this.getListeners("shutdown")){
+            try {
+                shutdownHandler();
+            } catch (error) {
+                this.emitPoolError(error, "Shutdown handler threw");
+            }
+        }
+        // ensure any error handlers are removed to avoid leaks
+        this.off("error");
+    }
+}

package/dist/cjs/socket/websocket-pool.d.ts

@@ -4,14 +4,47 @@ import type { Logger } from "ts-log";
 import type { Request } from "../protocol.js";
 import type { ResilientWebSocketConfig } from "./resilient-websocket.js";
 import { ResilientWebSocket } from "./resilient-websocket.js";
+import { IsomorphicEventEmitter } from "../emitter/index.js";
 type WebSocketOnMessageCallback = (data: WebSocket.Data) => void | Promise<void>;
 export type WebSocketPoolConfig = {
-    urls?: string[];
+    /**
+     * Maximum number of open, parallel websocket connections
+     * @defaultValue 3
+     */
     numConnections?: number;
-    rwsConfig?: Omit<ResilientWebSocketConfig, "logger" | "endpoint">;
+    /**
+     * Callback that will be executed whenever an error
+     * message or an error event occurs on an individual WebSocket connection
+     *
+     * @deprecated use onWebSocketError() instead
+     */
     onError?: (error: ErrorEvent) => void;
+    /**
+     * Callback that will be executed whenever an error
+     * message or an error event occurs on an individual WebSocket connection
+     */
+    onWebSocketError?: (error: ErrorEvent) => void;
+    /**
+     * Callback that will be executed whenever an error occurs
+     * directly within the WebSocket pool. These can typically
+     * be errors that would normally manifest as "unhandledRejection" or "uncaughtException"
+     * errors.
+     */
+    onWebSocketPoolError?: (error: Error) => void;
+    /**
+     * Additional websocket configuration
+     */
+    rwsConfig?: Omit<ResilientWebSocketConfig, "logger" | "endpoint">;
+    /**
+     * Pyth URLs to use when creating a connection
+     */
+    urls?: string[];
+};
+export type WebSocketPoolEvents = {
+    error: (error: Error) => void;
+    shutdown: () => void;
 };
-export declare class WebSocketPool {
+export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolEvents> {
     private readonly logger;
     rwsPool: ResilientWebSocket[];
     private cache;
@@ -30,6 +63,7 @@ export declare class WebSocketPool {
      * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
      */
     static create(config: WebSocketPoolConfig, token: string, logger?: Logger): Promise<WebSocketPool>;
+    private emitPoolError;
     /**
      * Checks for error responses in JSON messages and throws appropriate errors
      */

package/dist/cjs/util/{buffer-util.js → buffer-util.cjs}

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bufferFromWebsocketData = bufferFromWebsocketData;
 // the linting rules don't allow importing anything that might clash with
 // a global, top-level import. we disable this rule because we need this
 // imported from our installed dependency
 // eslint-disable-next-line unicorn/prefer-node-protocol
-const buffer_1 = require("buffer");
-const BufferClassToUse = "Buffer" in globalThis ? globalThis.Buffer : buffer_1.Buffer;
-/**
- * given a relatively unknown websocket frame data object,
- * returns a valid Buffer instance that is safe to use
- * isomorphically in any JS runtime environment
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "bufferFromWebsocketData", {
+    enumerable: true,
+    get: function() {
+        return bufferFromWebsocketData;
+    }
+});
+const _buffer = require("buffer");
+const BufferClassToUse = "Buffer" in globalThis ? globalThis.Buffer : _buffer.Buffer;
 async function bufferFromWebsocketData(data) {
     if (typeof data === "string") {
         return BufferClassToUse.from(new TextEncoder().encode(data).buffer);
     }
-    if (data instanceof BufferClassToUse)
-        return data;
+    if (data instanceof BufferClassToUse) return data;
     if (data instanceof Blob) {
         // let the uncaught promise exception bubble up if there's an issue
         return BufferClassToUse.from(await data.arrayBuffer());
     }
-    if (data instanceof ArrayBuffer)
-        return BufferClassToUse.from(data);
+    if (data instanceof ArrayBuffer) return BufferClassToUse.from(data);
     if (Array.isArray(data)) {
         // an array of buffers is highly unlikely, but it is a possibility
         // indicated by the WebSocket Data interface

package/dist/cjs/util/env-util.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get envIsBrowser () {
+        return envIsBrowser;
+    },
+    get envIsBrowserOrWorker () {
+        return envIsBrowserOrWorker;
+    },
+    get envIsServiceOrWebWorker () {
+        return envIsServiceOrWebWorker;
+    }
+});
+// we create this local-only type, which has assertions made to indicate
+// that we do not know and cannot guarantee which JS environment we are in
+const g = globalThis;
+function envIsServiceOrWebWorker() {
+    return typeof WorkerGlobalScope !== "undefined" && g.self instanceof WorkerGlobalScope;
+}
+function envIsBrowser() {
+    return g.window !== undefined;
+}
+function envIsBrowserOrWorker() {
+    return envIsServiceOrWebWorker() || envIsBrowser();
+}

package/dist/cjs/util/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./buffer-util.cjs"), exports);
+_export_star(require("./env-util.cjs"), exports);
+_export_star(require("./url-util.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/util/url-util.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addAuthTokenToWebSocketUrl", {
+    enumerable: true,
+    get: function() {
+        return addAuthTokenToWebSocketUrl;
+    }
+});
+const ACCESS_TOKEN_QUERY_PARAM_KEY = "ACCESS_TOKEN";
+function addAuthTokenToWebSocketUrl(baseUrl, authToken) {
+    if (!baseUrl || !authToken) return baseUrl;
+    const parsedUrl = new URL(baseUrl);
+    parsedUrl.searchParams.set(ACCESS_TOKEN_QUERY_PARAM_KEY, authToken);
+    return parsedUrl.toString();
+}