@n1xyz/nord-ts 0.0.21 → 0.1.0

package/dist/nord/api/market.d.ts

@@ -0,0 +1,36 @@
+import { MarketsStatsResponse, OrderbookQuery, OrderbookResponse, TradesQuery, TradesResponse, UserAccountIdsQuery, UserAccountIdsResponse } from "../../types";
+/**
+ * Get market statistics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Market statistics response
+ * @throws {NordError} If the request fails
+ */
+export declare function marketsStats(webServerUrl: string): Promise<MarketsStatsResponse>;
+/**
+ * Get trades for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Trades query parameters
+ * @returns Trades response
+ * @throws {NordError} If the request fails
+ */
+export declare function getTrades(webServerUrl: string, query: TradesQuery): Promise<TradesResponse>;
+/**
+ * Get user account IDs
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - User account IDs query parameters
+ * @returns User account IDs response
+ * @throws {NordError} If the request fails
+ */
+export declare function getUserAccountIds(webServerUrl: string, query: UserAccountIdsQuery): Promise<UserAccountIdsResponse>;
+/**
+ * Get orderbook for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Orderbook query parameters
+ * @returns Orderbook response
+ * @throws {NordError} If the request fails
+ */
+export declare function getOrderbook(webServerUrl: string, query: OrderbookQuery): Promise<OrderbookResponse>;

package/dist/nord/api/market.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketsStats = marketsStats;
+exports.getTrades = getTrades;
+exports.getUserAccountIds = getUserAccountIds;
+exports.getOrderbook = getOrderbook;
+const utils_1 = require("../../utils");
+const NordError_1 = require("../utils/NordError");
+/**
+ * Get market statistics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Market statistics response
+ * @throws {NordError} If the request fails
+ */
+async function marketsStats(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/stats`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to fetch markets stats", { cause: error });
+    }
+}
+/**
+ * Get trades for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Trades query parameters
+ * @returns Trades response
+ * @throws {NordError} If the request fails
+ */
+async function getTrades(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        params.append("accountId", query.accountId.toString());
+        if (query.since) {
+            params.append("since", query.since);
+        }
+        if (query.until) {
+            params.append("until", query.until);
+        }
+        if (query.pageId) {
+            params.append("pageId", query.pageId);
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/trades?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get trades", { cause: error });
+    }
+}
+/**
+ * Get user account IDs
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - User account IDs query parameters
+ * @returns User account IDs response
+ * @throws {NordError} If the request fails
+ */
+async function getUserAccountIds(webServerUrl, query) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/user/${query.pubkey.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get user account IDs", { cause: error });
+    }
+}
+/**
+ * Get orderbook for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Orderbook query parameters
+ * @returns Orderbook response
+ * @throws {NordError} If the request fails
+ */
+async function getOrderbook(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.symbol) {
+            params.append("symbol", query.symbol);
+        }
+        else if (query.market_id !== undefined) {
+            params.append("market_id", query.market_id.toString());
+        }
+        else {
+            throw new NordError_1.NordError("Either symbol or market_id must be provided for orderbook query");
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/orderbook?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get orderbook", { cause: error });
+    }
+}

package/dist/nord/api/queries.d.ts

@@ -0,0 +1,46 @@
+import { ActionQuery, ActionResponse, ActionsResponse, RollmanActionResponse, RollmanActionsResponse } from "../../types";
+/**
+ * Query a specific action
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Action response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryAction(webServerUrl: string, query: ActionQuery): Promise<ActionResponse>;
+/**
+ * Query recent actions
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param from - Starting action index
+ * @param to - Ending action index
+ * @returns Actions response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryRecentActions(webServerUrl: string, from: number, to: number): Promise<ActionsResponse>;
+/**
+ * Get the last action ID
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Last action ID
+ * @throws {NordError} If the request fails
+ */
+export declare function getLastActionId(webServerUrl: string): Promise<number>;
+/**
+ * Query an action from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Rollman action response
+ * @throws {NordError} If the request fails
+ */
+export declare function actionQueryRollman(webServerUrl: string, query: ActionQuery): Promise<RollmanActionResponse>;
+/**
+ * Query actions from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Rollman actions response
+ * @throws {NordError} If the request fails
+ */
+export declare function actionsQueryRollman(webServerUrl: string, last_n: number): Promise<RollmanActionsResponse>;

package/dist/nord/api/queries.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryAction = queryAction;
+exports.queryRecentActions = queryRecentActions;
+exports.getLastActionId = getLastActionId;
+exports.actionQueryRollman = actionQueryRollman;
+exports.actionsQueryRollman = actionsQueryRollman;
+const utils_1 = require("../../utils");
+const NordError_1 = require("../utils/NordError");
+/**
+ * Query a specific action
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Action response
+ * @throws {NordError} If the request fails
+ */
+async function queryAction(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.action_id !== undefined) {
+            params.append("action_id", query.action_id.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/action?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query action", { cause: error });
+    }
+}
+/**
+ * Query recent actions
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param from - Starting action index
+ * @param to - Ending action index
+ * @returns Actions response
+ * @throws {NordError} If the request fails
+ */
+async function queryRecentActions(webServerUrl, from, to) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/actions?from=${from}&to=${to}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query recent actions (from ${from} to ${to})`, {
+            cause: error,
+        });
+    }
+}
+/**
+ * Get the last action ID
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Last action ID
+ * @throws {NordError} If the request fails
+ */
+async function getLastActionId(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/actions/last-id`);
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get last action ID", {
+            cause: error,
+        });
+    }
+}
+/**
+ * Query an action from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Rollman action response
+ * @throws {NordError} If the request fails
+ */
+async function actionQueryRollman(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.action_id !== undefined) {
+            params.append("action_id", query.action_id.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/action?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query Rollman action", { cause: error });
+    }
+}
+/**
+ * Query actions from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Rollman actions response
+ * @throws {NordError} If the request fails
+ */
+async function actionsQueryRollman(webServerUrl, last_n) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/actions?last_n=${last_n}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query Rollman actions (last ${last_n})`, {
+            cause: error,
+        });
+    }
+}

package/dist/nord/client/Nord.js

@@ -41,7 +41,7 @@ const proton_1 = require("@n1xyz/proton");
 const web3_js_1 = require("@solana/web3.js");
 const events_1 = require("events");
 const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
-const proto = __importStar(require("../../gen/nord"));
+const proto = __importStar(require("../../gen/nord_pb"));
 const types_1 = require("../../types");
 const utils = __importStar(require("../../utils"));
 const core = __importStar(require("../api/core"));
@@ -240,8 +240,8 @@ class Nord {
         });
         return xs.map((x) => ({
             actionId: x.actionId,
-            action: utils.decodeLengthDelimited(Buffer.from(x.payload, "base64"), proto.Action),
-            physicalExecTime: new Date(x.physicalTime * 1000),
+            action: utils.decodeLengthDelimited(Buffer.from(x.payload, "base64"), proto.ActionSchema),
+            physicalExecTime: new Date(x.physicalTime),
         }));
     }
     /**

package/dist/nord/client/NordUser.d.ts

@@ -1,7 +1,7 @@
-import { Connection, PublicKey, Transaction } from "@solana/web3.js";
+import { Connection, PublicKey, Transaction, SendOptions } from "@solana/web3.js";
 import Decimal from "decimal.js";
-import { FillMode, Side, SPLTokenInfo } from "../../types";
-import * as proto from "../../gen/nord";
+import { FillMode, Side, SPLTokenInfo, QuoteSize } from "../../types";
+import * as proto from "../../gen/nord_pb";
 import { BigIntValue } from "../../utils";
 import { Nord } from "./Nord";
 /**
@@ -43,8 +43,8 @@ export interface PlaceOrderParams {
     size?: Decimal.Value;
     /** Order price */
     price?: Decimal.Value;
-    /** Quote size (for market orders) */
-    quoteSize?: Decimal.Value;
+    /** Quote size object (requires non-zero price and size) */
+    quoteSize?: QuoteSize;
     /** Account ID to place the order from */
     accountId?: number;
 }
@@ -83,8 +83,8 @@ export interface UserAtomicSubaction {
     size?: Decimal.Value;
     /** Order price */
     price?: Decimal.Value;
-    /** Quote size (for market orders) */
-    quoteSize?: Decimal.Value;
+    /** Quote size object (for market-style placement) */
+    quoteSize?: QuoteSize;
     /** The client order ID of the order. */
     clientOrderId?: BigIntValue;
 }
@@ -203,13 +203,15 @@ export declare class NordUser {
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
      * @param recipient - Recipient address; defaults to the user's address
+     * @param sendOptions - Send options for .sendTransaction
      * @returns Transaction signature
      * @throws {NordError} If required parameters are missing or operation fails
      */
-    deposit({ amount, tokenId, recipient, }: Readonly<{
+    deposit({ amount, tokenId, recipient, sendOptions, }: Readonly<{
         amount: number;
         tokenId: number;
         recipient?: PublicKey;
+        sendOptions?: SendOptions;
     }>): Promise<string>;
     /**
      * Get a new nonce for actions
@@ -265,19 +267,27 @@ export declare class NordUser {
      * Place an order on the exchange
      *
      * @param params - Order parameters
-     * @returns Order ID if successful
+     * @returns Object containing actionId, orderId (if posted), fills, and clientOrderId
      * @throws {NordError} If the operation fails
      */
-    placeOrder(params: PlaceOrderParams): Promise<bigint | undefined>;
+    placeOrder(params: PlaceOrderParams): Promise<{
+        actionId: bigint;
+        orderId?: bigint;
+        fills: proto.Receipt_Trade[];
+    }>;
     /**
      * Cancel an order
      *
      * @param orderId - Order ID to cancel
      * @param providedAccountId - Account ID that placed the order
-     * @returns Action ID if successful
+     * @returns Object containing actionId, cancelled orderId, and accountId
      * @throws {NordError} If the operation fails
      */
-    cancelOrder(orderId: BigIntValue, providedAccountId?: number): Promise<bigint>;
+    cancelOrder(orderId: BigIntValue, providedAccountId?: number): Promise<{
+        actionId: bigint;
+        orderId: bigint;
+        accountId: number;
+    }>;
     /**
      * Transfer tokens to another account
      *
@@ -297,7 +307,10 @@ export declare class NordUser {
      * @param userActions array of user-friendly subactions
      * @param providedAccountId optional account performing the action (defaults to first account)
      */
-    atomic(userActions: UserAtomicSubaction[], providedAccountId?: number): Promise<proto.Receipt_AtomicResult>;
+    atomic(userActions: UserAtomicSubaction[], providedAccountId?: number): Promise<{
+        actionId: bigint;
+        results: proto.Receipt_AtomicSubactionResultKind[];
+    }>;
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/nord/client/NordUser.js

@@ -242,10 +242,11 @@ class NordUser {
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
      * @param recipient - Recipient address; defaults to the user's address
+     * @param sendOptions - Send options for .sendTransaction
      * @returns Transaction signature
      * @throws {NordError} If required parameters are missing or operation fails
      */
-    async deposit({ amount, tokenId, recipient, }) {
+    async deposit({ amount, tokenId, recipient, sendOptions, }) {
         try {
             // Find the token info
             const tokenInfo = this.splTokenInfos.find((t) => t.tokenId === tokenId);
@@ -262,14 +263,14 @@ class NordUser {
                 mint,
                 sourceTokenAccount: fromAccount,
             });
-            const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+            const { blockhash } = await this.connection.getLatestBlockhash();
             const tx = new web3_js_1.Transaction();
             tx.add(ix);
             tx.recentBlockhash = blockhash;
             tx.feePayer = payer;
             const signedTx = await this.transactionSignFn(tx);
             signedTx.partialSign(extraSigner);
-            const signature = await this.connection.sendRawTransaction(signedTx.serialize());
+            const signature = await this.connection.sendRawTransaction(signedTx.serialize(), sendOptions);
             return signature;
         }
         catch (error) {
@@ -345,10 +346,11 @@ class NordUser {
      * @throws {NordError} If the operation fails
      */
     async refreshSession() {
-        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+        const result = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
             userPubkey: (0, utils_1.optExpect)(this.publicKey.toBytes(), "No user's public key"),
             sessionPubkey: this.sessionPubKey,
         });
+        this.sessionId = result.sessionId;
     }
     /**
      * Revoke a session
@@ -404,7 +406,7 @@ class NordUser {
      * Place an order on the exchange
      *
      * @param params - Order parameters
-     * @returns Order ID if successful
+     * @returns Object containing actionId, orderId (if posted), fills, and clientOrderId
      * @throws {NordError} If the operation fails
      */
     async placeOrder(params) {
@@ -414,7 +416,7 @@ class NordUser {
             if (!market) {
                 throw new NordError_1.NordError(`Market with ID ${params.marketId} not found`);
             }
-            return (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+            const result = await (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
                 sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
                 senderId: params.accountId,
                 sizeDecimals: market.sizeDecimals,
@@ -427,6 +429,7 @@ class NordUser {
                 price: params.price,
                 quoteSize: params.quoteSize,
             });
+            return result;
         }
         catch (error) {
             throw new NordError_1.NordError("Failed to place order", { cause: error });
@@ -437,18 +440,19 @@ class NordUser {
      *
      * @param orderId - Order ID to cancel
      * @param providedAccountId - Account ID that placed the order
-     * @returns Action ID if successful
+     * @returns Object containing actionId, cancelled orderId, and accountId
      * @throws {NordError} If the operation fails
      */
     async cancelOrder(orderId, providedAccountId) {
         const accountId = providedAccountId != null ? providedAccountId : this.accountIds?.[0];
         try {
             this.checkSessionValidity();
-            return (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+            const result = await (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
                 sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
                 senderId: accountId,
                 orderId,
             });
+            return result;
         }
         catch (error) {
             throw new NordError_1.NordError(`Failed to cancel order ${orderId}`, {
@@ -514,8 +518,7 @@ class NordUser {
                         priceDecimals: market.priceDecimals,
                         size: act.size,
                         price: act.price,
-                        quoteSizeSize: act.quoteSize, // treated as quote size; we pass only size component
-                        quoteSizePrice: undefined,
+                        quoteSize: act.quoteSize,
                         clientOrderId: act.clientOrderId,
                     };
                 }

package/dist/types.d.ts

@@ -1,5 +1,6 @@
-import * as proto from "./gen/nord";
+import * as proto from "./gen/nord_pb";
 import type { components } from "./gen/openapi.ts";
+import Decimal from "decimal.js";
 /**
  * The peak TPS rate is queried over the specified period.
  * The period is specified in units of: {hour, day, week, month, year}.
@@ -249,3 +250,13 @@ export interface SPLTokenInfo {
     tokenId: number;
     name: string;
 }
+export declare class QuoteSize {
+    price: Decimal;
+    size: Decimal;
+    constructor(quotePrice: Decimal.Value, quoteSize: Decimal.Value);
+    value(): Decimal;
+    toScaledU64(marketPriceDecimals: number, marketSizeDecimals: number): {
+        price: bigint;
+        size: bigint;
+    };
+}

package/dist/types.js

@@ -32,10 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketMessageType = exports.FillMode = exports.Side = exports.KeyType = exports.PeakTpsPeriodUnit = void 0;
+exports.QuoteSize = exports.WebSocketMessageType = exports.FillMode = exports.Side = exports.KeyType = exports.PeakTpsPeriodUnit = void 0;
 exports.fillModeToProtoFillMode = fillModeToProtoFillMode;
-const proto = __importStar(require("./gen/nord"));
+const proto = __importStar(require("./gen/nord_pb"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const utils_1 = require("./utils");
 /**
  * The peak TPS rate is queried over the specified period.
  * The period is specified in units of: {hour, day, week, month, year}.
@@ -99,3 +104,25 @@ var WebSocketMessageType;
     WebSocketMessageType["DeltaUpdate"] = "delta";
     WebSocketMessageType["AccountUpdate"] = "account";
 })(WebSocketMessageType || (exports.WebSocketMessageType = WebSocketMessageType = {}));
+// Positive decimal price and size.
+class QuoteSize {
+    constructor(quotePrice, quoteSize) {
+        const p = new decimal_js_1.default(quotePrice);
+        const s = new decimal_js_1.default(quoteSize);
+        if (!p.isPositive() || !s.isPositive()) {
+            throw new Error("quotePrice and quoteSize must be positive");
+        }
+        this.price = p;
+        this.size = s;
+    }
+    value() {
+        return this.price.mul(this.size);
+    }
+    toScaledU64(marketPriceDecimals, marketSizeDecimals) {
+        return {
+            price: (0, utils_1.toScaledU64)(this.price, marketPriceDecimals),
+            size: (0, utils_1.toScaledU64)(this.size, marketSizeDecimals),
+        };
+    }
+}
+exports.QuoteSize = QuoteSize;

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import { Decimal } from "decimal.js";
 import { KeyType, type Market, type Token } from "./types";
-import * as proto from "./gen/nord";
+import { type Message } from "@bufbuild/protobuf";
+import type { GenMessage } from "@bufbuild/protobuf/codegenv2";
 import { ethers } from "ethers";
 import { RequestInfo, RequestInit, Response } from "node-fetch";
 import { Keypair } from "@solana/web3.js";
@@ -68,30 +69,15 @@ export declare const toScaledU64: (x: Decimal.Value, decimals: number) => bigint
  * @returns         Rescaled unsigned integer
  */
 export declare const toScaledU128: (x: Decimal.Value, decimals: number) => bigint;
-/**
- * Encodes any protobuf message into a length-delimited format,
- * i.e. prefixed with its length encoded as varint
- * @param   message message object
- * @param   coder   associated coder object which implements `MessageFns` interface
- * @returns         Encoded message as Uint8Array, prefixed with its length
- */
-export declare function encodeLengthDelimited<T, M extends proto.MessageFns<T>>(message: T, coder: M): Uint8Array;
 /**
  * Decodes any protobuf message from a length-delimited format,
  * i.e. prefixed with its length encoded as varint
  *
- * NB: Please note that due to limitations of Typescript type inference
- * it requires to specify variable type explicitly:
- *
- * ```
- * const foo: proto.Bar = decodeLengthDelimited(bytes, proto.Bar);
- * ```
- *
- * @param   bytes Byte array with encoded message
- * @param   coder associated coder object which implements `MessageFns` interface
- * @returns       Decoded Action as Uint8Array.
+ * @param   bytes  Byte array with encoded message
+ * @param   schema Message schema for decoding
+ * @returns        Decoded message
  */
-export declare function decodeLengthDelimited<T, M extends proto.MessageFns<T>>(bytes: Uint8Array, coder: M): T;
+export declare function decodeLengthDelimited<T extends Message>(bytes: Uint8Array, schema: GenMessage<T>): T;
 export declare function checkPubKeyLength(keyType: KeyType, len: number): void;
 export declare function findMarket(markets: Market[], marketId: number): Market;
 export declare function findToken(tokens: Token[], tokenId: number): Token;