@n1xyz/nord-ts 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./utils";
+export * from "./abis";
+export * from "./nord";
+export * from "./const";

package/dist/index.js

@@ -0,0 +1,21 @@
+"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("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./abis"), exports);
+__exportStar(require("./nord"), exports);
+__exportStar(require("./const"), exports);

package/dist/nord/Nord.d.ts

@@ -0,0 +1,76 @@
+import { ActionQuery, ActionResponse, ActionsResponse, AggregateMetrics, BlockQuery, BlockResponse, BlockSummaryResponse, type DeltaEvent, ERC20TokenInfo, type Market, NordConfig, PeakTpsPeriodUnit, RollmanActionResponse, RollmanActionsResponse, RollmanBlockResponse, MarketsStatsResponse, type SubscriberConfig, type Token, type Trades, type Account, type OrderbookResponse, type TradesResponse, type TradesQueryParams } from "../types";
+import { NordImpl } from "./NordImpl";
+export declare function depositOnlyTx(privateAddress: string, publicKey: Uint8Array, amount: number, precision: number, contractAddress: string): Promise<string>;
+export declare function depositOnlyTxRaw(privateAddress: string, publicKey: Uint8Array, amount: number, precision: number, contractAddress: string): Promise<string>;
+export declare class Nord {
+    impl: NordImpl;
+    evmUrl: string;
+    webServerUrl: string;
+    contractAddress: string;
+    tokenInfos: ERC20TokenInfo[];
+    markets: Market[];
+    tokens: Token[];
+    constructor({ evmUrl, webServerUrl, tokenInfos, contractAddress, }: NordConfig);
+    getTimestamp(): Promise<bigint>;
+    getActionNonce(): Promise<number>;
+    fetchNordInfo(): Promise<void>;
+    static initNord(nordConfig: NordConfig): Promise<Nord>;
+    static initDevNord(): Promise<Nord>;
+    marketsStats(): Promise<MarketsStatsResponse>;
+    queryBlock(query: BlockQuery): Promise<BlockResponse>;
+    queryLastNBlocks(): Promise<BlockResponse>;
+    queryRecentBlocks(last_n: number): Promise<BlockSummaryResponse>;
+    queryAction(query: ActionQuery): Promise<ActionResponse>;
+    queryRecentActions(last_n: number): Promise<ActionsResponse>;
+    aggregateMetrics(txPeakTpsPeriod?: number, txPeakTpsPeriodUnit?: PeakTpsPeriodUnit): Promise<AggregateMetrics>;
+    getCurrentTps(period?: string): Promise<number>;
+    getPeakTps(period?: string): Promise<number>;
+    getMedianLatency(period?: string): Promise<number>;
+    getTotalTransactions(): Promise<string>;
+    blockQueryRollman(query: BlockQuery): Promise<RollmanBlockResponse>;
+    blockSummaryQueryRollman(last_n: number): Promise<BlockSummaryResponse>;
+    actionQueryRollman(query: ActionQuery): Promise<RollmanActionResponse>;
+    actionsQueryRollman(last_n: number): Promise<RollmanActionsResponse>;
+    queryPrometheus(params: string): Promise<number>;
+    static approveTx(privateAddress: string, erc20address: string, contractAddress: string): Promise<void>;
+    /**
+     * Fetches a sequence of actions between specified action IDs
+     * @param fromActionId - Starting action ID
+     * @param toActionId - Ending action ID
+     * @returns A promise that resolves to an ActionsResponse
+     */
+    getActions(fromActionId: number, toActionId: number): Promise<ActionsResponse>;
+    /**
+     * Fetches trades for a specified account
+     * @param params - Query parameters for fetching trades
+     * @returns A promise that resolves to a TradesResponse
+     */
+    getTrades(params: TradesQueryParams): Promise<TradesResponse>;
+    /**
+     * Fetches the orderbook for a specified market
+     * @param symbol - Market symbol
+     * @returns A promise that resolves to an OrderbookResponse
+     */
+    getOrderbook(symbol: string): Promise<OrderbookResponse>;
+}
+export declare class Subscriber {
+    streamURL: string;
+    buffer: (DeltaEvent | Trades | Account)[];
+    maxBufferLen: number;
+    constructor(config: SubscriberConfig);
+    subscribe(): void;
+}
+/**
+ * Creates a WebSocket subscription to specified streams
+ * @param baseUrl - Base URL of the API
+ * @param streams - Array of streams to subscribe to
+ * @returns A Subscriber instance
+ *
+ * Syntax for streams:
+ * - trades@<symbol>: Subscribe to trades for a market
+ * - deltas@<symbol>: Subscribe to orderbook deltas for a market
+ * - user@<user id>: Subscribe to user account updates
+ *
+ * Example: createWebSocketSubscription('https://alpha-api.layern.network', ['trades@BTCUSDC', 'deltas@BTCUSDC', 'user@0'])
+ */
+export declare function createWebSocketSubscription(baseUrl: string, streams: string[]): Subscriber;

package/dist/nord/Nord.js

@@ -0,0 +1,376 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = exports.Nord = void 0;
+exports.depositOnlyTx = depositOnlyTx;
+exports.depositOnlyTxRaw = depositOnlyTxRaw;
+exports.createWebSocketSubscription = createWebSocketSubscription;
+const ethers_1 = require("ethers");
+const ws_1 = __importDefault(require("ws"));
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const const_1 = require("../const");
+const abis_1 = require("../abis");
+const proto = __importStar(require("../gen/nord"));
+async function depositOnlyTx(privateAddress, publicKey, amount, precision, contractAddress) {
+    const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
+    const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
+    const nordContract = new ethers_1.ethers.Contract(contractAddress, abis_1.NORD_RAMP_FACET_ABI, wallet);
+    const depositTx = await nordContract.depositUnchecked(publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), precision), {
+        gasLimit: 1000000,
+        maxFeePerGas: ethers_1.ethers.parseUnits("100", "gwei"),
+        maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.01", "gwei"),
+    });
+    return depositTx.hash;
+}
+async function depositOnlyTxRaw(privateAddress, publicKey, amount, precision, contractAddress) {
+    const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
+    const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
+    const nordContract = new ethers_1.ethers.Contract(contractAddress, abis_1.NORD_RAMP_FACET_ABI, wallet);
+    const depositTx = await nordContract.depositUnchecked.populateTransaction(publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), precision), {
+        maxFeePerGas: ethers_1.ethers.parseUnits("0.0003", "gwei"),
+        maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.0003", "gwei"),
+    });
+    return JSON.stringify(depositTx);
+}
+function makeNordImpl(nord) {
+    return {
+        getTimestamp: () => nord.getTimestamp().then((x) => x + 1n),
+    };
+}
+class Nord {
+    constructor({ evmUrl, webServerUrl, tokenInfos, contractAddress, }) {
+        this.impl = makeNordImpl(this);
+        this.evmUrl = evmUrl;
+        this.webServerUrl = webServerUrl;
+        this.tokenInfos = tokenInfos;
+        this.contractAddress = contractAddress;
+        this.markets = [];
+        this.tokens = [];
+    }
+    async getTimestamp() {
+        const resp = await (await (0, utils_1.checkedFetch)(`${this.webServerUrl}/timestamp`, { method: "GET" })).json();
+        return BigInt(resp);
+    }
+    async getActionNonce() {
+        const resp = await (await (0, utils_1.checkedFetch)(`${this.webServerUrl}/action_nonce`, { method: "GET" })).json();
+        return resp;
+    }
+    async fetchNordInfo() {
+        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/info`, {
+            method: "GET",
+        });
+        const info = await response.json();
+        this.markets = info.markets;
+        this.tokens = info.tokens;
+    }
+    static async initNord(nordConfig) {
+        const nord = new Nord(nordConfig);
+        await nord.fetchNordInfo();
+        return nord;
+    }
+    static async initDevNord() {
+        const nord = new Nord({
+            evmUrl: const_1.EVM_DEV_URL,
+            webServerUrl: const_1.WEBSERVER_DEV_URL,
+            tokenInfos: const_1.DEV_TOKEN_INFOS,
+            contractAddress: const_1.DEV_CONTRACT_ADDRESS,
+        });
+        await nord.fetchNordInfo();
+        return nord;
+    }
+    async marketsStats() {
+        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/stats`, {
+            method: "GET",
+        });
+        const stats = await response.json();
+        return stats;
+    }
+    // Query the block info from rollman.
+    async queryBlock(query) {
+        const rollmanResponse = await this.blockQueryRollman(query);
+        const queryResponse = {
+            block_number: rollmanResponse.block_number,
+            actions: [],
+        };
+        for (const rollmanAction of rollmanResponse.actions) {
+            const blockAction = {
+                action_id: rollmanAction.action_id,
+                action: (0, utils_1.decodeLengthDelimited)(new Uint8Array(rollmanAction.action_pb), proto.Action),
+                exec_timestamp: rollmanAction.exec_timestamp,
+            };
+            queryResponse.actions.push(blockAction);
+        }
+        return queryResponse;
+    }
+    // Query the block info from rollman.
+    async queryLastNBlocks() {
+        const rollmanResponse = await this.blockQueryRollman({});
+        const queryResponse = {
+            block_number: rollmanResponse.block_number,
+            actions: [],
+        };
+        for (const rollmanAction of rollmanResponse.actions) {
+            const blockAction = {
+                action_id: rollmanAction.action_id,
+                action: (0, utils_1.decodeLengthDelimited)(rollmanAction.action_pb, proto.Action),
+                exec_timestamp: rollmanAction.exec_timestamp,
+            };
+            queryResponse.actions.push(blockAction);
+        }
+        return queryResponse;
+    }
+    // Query the block summary of recent blocks from rollman.
+    async queryRecentBlocks(last_n) {
+        const response = await this.blockSummaryQueryRollman(last_n);
+        return response;
+    }
+    // Query the action info from rollman.
+    async queryAction(query) {
+        const rollmanResponse = await this.actionQueryRollman(query);
+        return {
+            block_number: rollmanResponse.block_number,
+            action: (0, utils_1.decodeLengthDelimited)(rollmanResponse.action_pb, proto.Action),
+        };
+    }
+    // Query the recent transactions from rollman.
+    async queryRecentActions(last_n) {
+        const rollmanResponse = await this.actionsQueryRollman(last_n);
+        const queryResponse = {
+            actions: [],
+        };
+        for (const rollmanExtendedAction of rollmanResponse.actions) {
+            const extendedActionInfo = {
+                block_number: rollmanExtendedAction.block_number,
+                action_id: rollmanExtendedAction.action_id,
+                action: (0, utils_1.decodeLengthDelimited)(rollmanExtendedAction.action_pb, proto.Action),
+            };
+            queryResponse.actions.push(extendedActionInfo);
+        }
+        return queryResponse;
+    }
+    // Query the aggregate metrics across nord and rollman.
+    async aggregateMetrics(txPeakTpsPeriod = 1, txPeakTpsPeriodUnit = types_1.PeakTpsPeriodUnit.Day) {
+        // Get the latest block number for L2 blocks.
+        const blockQuery = {};
+        const rollmanResponse = await this.blockQueryRollman(blockQuery);
+        const period = txPeakTpsPeriod.toString() + txPeakTpsPeriodUnit;
+        const query = `max_over_time(rate(nord_requests_ok_count[1m])[${period}:1m])`;
+        return {
+            blocks_total: rollmanResponse.block_number,
+            tx_total: await this.queryPrometheus("nord_requests_ok_count"),
+            tx_tps: await this.getCurrentTps(),
+            tx_tps_peak: await this.queryPrometheus(query),
+            request_latency_average: await this.queryPrometheus('nord_requests_ok_latency{quantile="0.5"}'),
+        };
+    }
+    async getCurrentTps(period = "1m") {
+        return await this.queryPrometheus("rate(nord_requests_ok_count[" + period + "])");
+    }
+    async getPeakTps(period = "24h") {
+        return await this.queryPrometheus("max_over_time(rate(nord_requests_ok_count[30s])[" + period + ":])");
+    }
+    async getMedianLatency(period = "1m") {
+        return await this.queryPrometheus(`avg_over_time(nord_requests_ok_latency{quantile="0.5"}[${period}])`);
+    }
+    async getTotalTransactions() {
+        return await (await (0, utils_1.checkedFetch)(this.webServerUrl + "/last_actionid")).text();
+    }
+    // Helper to query rollman for block info.
+    async blockQueryRollman(query) {
+        let url = this.webServerUrl + "/block_query";
+        if (query.block_number != null) {
+            url = url + "?block_number=" + query.block_number;
+        }
+        const response = await (0, utils_1.checkedFetch)(url);
+        if (!response.ok) {
+            throw new Error("Rollman query failed " + url);
+        }
+        return await response.json();
+    }
+    // Helper to query rollman for recent block summary.
+    async blockSummaryQueryRollman(last_n) {
+        const url = this.webServerUrl + "/last_n_blocks?last_n=" + last_n;
+        const response = await (0, utils_1.checkedFetch)(url);
+        if (!response.ok) {
+            throw new Error("Rollman query failed " + url);
+        }
+        return await response.json();
+    }
+    // Helper to query rollman for action info.
+    async actionQueryRollman(query) {
+        const url = this.webServerUrl + "/tx_query?action_id=" + query.action_id;
+        const response = await (0, utils_1.checkedFetch)(url);
+        if (!response.ok) {
+            throw new Error("Rollman query failed " + url);
+        }
+        return await response.json();
+    }
+    // Helper to query rollman for recent actions.
+    async actionsQueryRollman(last_n) {
+        const url = this.webServerUrl + "/last_n_actions?last_n=" + last_n;
+        const response = await (0, utils_1.checkedFetch)(url);
+        if (!response.ok) {
+            throw new Error("Rollman query failed " + url);
+        }
+        return await response.json();
+    }
+    // Helper to query prometheus.
+    async queryPrometheus(params) {
+        const url = this.webServerUrl + "/prometheus_query?query=" + params;
+        const response = await (0, utils_1.checkedFetch)(url);
+        if (!response.ok) {
+            throw new Error("Prometheus query failed " + url);
+        }
+        const json = await response.json();
+        // Prometheus HTTP API: https://prometheus.io/docs/prometheus/latest/querying/api/
+        return Number(json.data.result[0].value[1]);
+    }
+    static async approveTx(privateAddress, erc20address, contractAddress) {
+        const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
+        const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
+        const erc20Contract = new ethers_1.ethers.Contract(erc20address, abis_1.ERC20_ABI, wallet);
+        const maxUint256 = ethers_1.ethers.MaxUint256;
+        const approveTx = await erc20Contract.approve(contractAddress, maxUint256.toString(), {
+            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        });
+        return approveTx.hash;
+    }
+    /**
+     * Fetches a sequence of actions between specified action IDs
+     * @param fromActionId - Starting action ID
+     * @param toActionId - Ending action ID
+     * @returns A promise that resolves to an ActionsResponse
+     */
+    async getActions(fromActionId, toActionId) {
+        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/actions?from=${fromActionId}&to=${toActionId}`, { method: "GET" });
+        const rawResponse = await response.json();
+        const queryResponse = {
+            actions: [],
+        };
+        if (Array.isArray(rawResponse.actions)) {
+            for (const action of rawResponse.actions) {
+                const extendedActionInfo = {
+                    block_number: action.block_number,
+                    action_id: action.action_id,
+                    action: (0, utils_1.decodeLengthDelimited)(action.action_pb, proto.Action),
+                };
+                queryResponse.actions.push(extendedActionInfo);
+            }
+        }
+        return queryResponse;
+    }
+    /**
+     * Fetches trades for a specified account
+     * @param params - Query parameters for fetching trades
+     * @returns A promise that resolves to a TradesResponse
+     */
+    async getTrades(params) {
+        const { accountId, since, until, pageId } = params;
+        let url = `${this.webServerUrl}/trades?accountId=${accountId}`;
+        if (since) {
+            url += `&since=${encodeURIComponent(since)}`;
+        }
+        if (until) {
+            url += `&until=${encodeURIComponent(until)}`;
+        }
+        if (pageId) {
+            url += `&pageId=${encodeURIComponent(pageId)}`;
+        }
+        const response = await (0, utils_1.checkedFetch)(url, { method: "GET" });
+        const tradesResponse = await response.json();
+        return tradesResponse;
+    }
+    /**
+     * Fetches the orderbook for a specified market
+     * @param symbol - Market symbol
+     * @returns A promise that resolves to an OrderbookResponse
+     */
+    async getOrderbook(symbol) {
+        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/orderbook?symbol=${encodeURIComponent(symbol)}`, { method: "GET" });
+        const orderbook = await response.json();
+        return orderbook;
+    }
+}
+exports.Nord = Nord;
+class Subscriber {
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen || utils_1.MAX_BUFFER_LEN;
+    }
+    subscribe() {
+        const ws = new ws_1.default(this.streamURL);
+        ws.on("message", (data) => {
+            try {
+                const parsed = JSON.parse(data.toString());
+                this.buffer.push(parsed);
+                if (this.buffer.length > this.maxBufferLen) {
+                    this.buffer.shift();
+                }
+            }
+            catch (e) {
+                console.error("Failed to parse websocket message", e);
+            }
+        });
+    }
+}
+exports.Subscriber = Subscriber;
+/**
+ * Creates a WebSocket subscription to specified streams
+ * @param baseUrl - Base URL of the API
+ * @param streams - Array of streams to subscribe to
+ * @returns A Subscriber instance
+ *
+ * Syntax for streams:
+ * - trades@<symbol>: Subscribe to trades for a market
+ * - deltas@<symbol>: Subscribe to orderbook deltas for a market
+ * - user@<user id>: Subscribe to user account updates
+ *
+ * Example: createWebSocketSubscription('https://alpha-api.layern.network', ['trades@BTCUSDC', 'deltas@BTCUSDC', 'user@0'])
+ */
+function createWebSocketSubscription(baseUrl, streams) {
+    const streamPath = streams.join('&');
+    const wsUrl = baseUrl.replace(/^http/, 'ws') + `/ws/${streamPath}`;
+    const subscriber = new Subscriber({
+        streamURL: wsUrl,
+    });
+    subscriber.subscribe();
+    return subscriber;
+}

package/dist/nord/NordImpl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Implementation of some functions backing Nord and NordUser as interface,
+ * for mocking reasons
+ */
+export interface NordImpl {
+    getTimestamp: () => Promise<bigint>;
+}

package/dist/nord/NordImpl.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Implementation of some functions backing Nord and NordUser as interface,
+ * for mocking reasons
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nord/NordUser.d.ts

@@ -0,0 +1,77 @@
+import { BrowserProvider } from "ethers";
+import { BigIntValue } from "../utils";
+import { FillMode, Order, Side } from "../types";
+import { Nord } from "./Nord";
+import Decimal from "decimal.js";
+export declare class NordUser {
+    nord: Nord;
+    address: string;
+    walletSignFn: (message: Uint8Array | string) => Promise<string>;
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    balances: {
+        [key: string]: {
+            accountId: number;
+            balance: number;
+            symbol: string;
+        }[];
+    };
+    orders: {
+        [key: string]: Order[];
+    };
+    accountIds?: number[];
+    sessionId?: bigint;
+    publicKey: Uint8Array | undefined;
+    lastTs: number;
+    lastNonce: number;
+    constructor(params: {
+        nord: Nord;
+        address: string;
+        walletSignFn: (message: Uint8Array | string) => Promise<string>;
+        sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    });
+    clone(): NordUser;
+    /**
+     * Generates a nonce based on the current timestamp.
+     * @returns Generated nonce as a number.
+     */
+    getNonce(): number;
+    updateAccountId(): Promise<void>;
+    fetchInfo(): Promise<void>;
+    setPublicKey(): Promise<void>;
+    fundEthWallet(): Promise<void>;
+    fundErc20Wallet(): Promise<void>;
+    refreshSession(sessionPk: Uint8Array): Promise<void>;
+    /**
+     * Revokes session previously created by user
+     *
+     * @param sessionId - session identifier
+     */
+    revokeSession(sessionId: BigIntValue): Promise<void>;
+    deposit(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
+    depositApproveTx(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
+    depositOnlyTx(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
+    depositEth(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
+    withdraw(tokenId: number, amount: number): Promise<void>;
+    placeOrder(params: {
+        marketId: number;
+        side: Side;
+        fillMode: FillMode;
+        isReduceOnly: boolean;
+        size?: Decimal.Value;
+        price?: Decimal.Value;
+        quoteSize?: Decimal.Value;
+        accountId?: number;
+    }): Promise<bigint | undefined>;
+    cancelOrder(orderId: BigIntValue, accountId: number): Promise<bigint>;
+    transferToAccount(params: {
+        to: NordUser;
+        tokenId: number;
+        amount: Decimal.Value;
+        fromAccountId: number;
+        toAccountId: number;
+    }): Promise<void>;
+    createAccount(params: {
+        tokenId: number;
+        amount: Decimal.Value;
+    }): Promise<NordUser>;
+}