@n1xyz/nord-ts 0.0.4 → 0.0.7

package/dist/nord/NordUser.js

@@ -1,481 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NordUser = void 0;
-const spl_token_1 = require("@solana/spl-token");
-const web3_js_1 = require("@solana/web3.js");
-const utils_1 = require("../utils");
-const actions_1 = require("./actions");
-const client_1 = require("../bridge/client");
-const utils_2 = require("../bridge/utils");
-const NordError_1 = require("./NordError");
-/**
- * User class for interacting with the Nord protocol
- */
-class NordUser {
-    /**
-     * Create a new NordUser instance
-     *
-     * @param params - Parameters for creating a NordUser
-     * @throws {NordError} If required parameters are missing
-     */
-    constructor(params) {
-        /** User balances by token symbol */
-        this.balances = {};
-        /** User orders by market symbol */
-        this.orders = {};
-        /** Last timestamp used */
-        this.lastTs = 0;
-        /** Last nonce used */
-        this.lastNonce = 0;
-        /** SPL token information */
-        this.splTokenInfos = [];
-        if (!params.nord) {
-            throw new NordError_1.NordError("Nord instance is required");
-        }
-        if (!params.address) {
-            throw new NordError_1.NordError("Address is required");
-        }
-        if (!params.walletSignFn) {
-            throw new NordError_1.NordError("Wallet sign function is required");
-        }
-        if (!params.sessionSignFn) {
-            throw new NordError_1.NordError("Session sign function is required");
-        }
-        this.nord = params.nord;
-        this.address = params.address;
-        this.walletSignFn = params.walletSignFn;
-        this.sessionSignFn = params.sessionSignFn;
-        // Initialize Solana-specific properties if provided
-        if (params.solanaPublicKey) {
-            this.solanaPublicKey = typeof params.solanaPublicKey === 'string'
-                ? new web3_js_1.PublicKey(params.solanaPublicKey)
-                : params.solanaPublicKey;
-        }
-        this.keypair = params.keypair;
-        this.connection = params.connection;
-        // Convert TokenInfo to SPLTokenInfo if nord has tokenInfos
-        if (this.nord.tokenInfos) {
-            this.splTokenInfos = this.nord.tokenInfos.map(tokenInfo => ({
-                mint: tokenInfo.address, // Use address as mint
-                precision: tokenInfo.precision,
-                tokenId: tokenInfo.tokenId,
-                name: tokenInfo.name
-            }));
-        }
-        // Initialize bridge client if keypair and connection are provided
-        if (this.keypair && this.connection && this.nord.solanaProgramId) {
-            this.initBridgeClient();
-        }
-    }
-    /**
-     * Create a clone of this NordUser instance
-     *
-     * @returns A new NordUser instance with the same properties
-     */
-    clone() {
-        const newUser = new NordUser({
-            nord: this.nord,
-            address: this.address,
-            walletSignFn: this.walletSignFn,
-            sessionSignFn: this.sessionSignFn,
-            solanaPublicKey: this.solanaPublicKey,
-            keypair: this.keypair,
-            connection: this.connection
-        });
-        newUser.publicKey = this.publicKey;
-        newUser.lastTs = this.lastTs;
-        newUser.lastNonce = this.lastNonce;
-        newUser.accountIds = this.accountIds ? [...this.accountIds] : undefined;
-        newUser.sessionId = this.sessionId;
-        newUser.splTokenInfos = [...this.splTokenInfos];
-        // Deep clone balances and orders
-        newUser.balances = JSON.parse(JSON.stringify(this.balances));
-        newUser.orders = JSON.parse(JSON.stringify(this.orders));
-        return newUser;
-    }
-    /**
-     * Initialize the Solana bridge client
-     *
-     * @private
-     * @throws {NordError} If required parameters are missing
-     */
-    initBridgeClient() {
-        if (!this.keypair || !this.connection || !this.nord.solanaProgramId) {
-            throw new NordError_1.NordError('Keypair, connection, and program ID are required to initialize bridge client');
-        }
-        // Create an Anchor wallet from the keypair
-        const wallet = {
-            publicKey: this.keypair.publicKey,
-            signTransaction: async (tx) => {
-                tx.partialSign(this.keypair);
-                return tx;
-            },
-            signAllTransactions: async (txs) => {
-                return txs.map(tx => {
-                    tx.partialSign(this.keypair);
-                    return tx;
-                });
-            },
-            // Add payer property to satisfy NodeWallet interface
-            payer: this.keypair
-        };
-        // Initialize the bridge client
-        this.bridgeClient = new client_1.SolanaBridgeClient({
-            rpcUrl: this.connection.rpcEndpoint,
-            programId: this.nord.solanaProgramId,
-            commitment: 'confirmed',
-            tokenInfos: this.splTokenInfos
-        }, wallet);
-    }
-    /**
-     * Create a NordUser from a private key
-     *
-     * @param nord - Nord instance
-     * @param privateKey - Private key as string or Uint8Array
-     * @param connection - Solana connection (optional)
-     * @returns NordUser instance
-     * @throws {NordError} If the private key is invalid
-     */
-    static fromPrivateKey(nord, privateKey, connection) {
-        try {
-            const keypair = (0, utils_2.keypairFromPrivateKey)(privateKey);
-            // Create a signing function that returns Uint8Array
-            const walletSignFn = async (message) => {
-                const messageBuffer = typeof message === 'string'
-                    ? Buffer.from(message)
-                    : Buffer.from(message);
-                // Use nacl for signing since Keypair doesn't have a sign method
-                // This is a simplified version - in a real implementation, you would use proper signing
-                return Buffer.from(keypair.secretKey.slice(0, 64)).toString('hex');
-            };
-            const sessionSignFn = async (message) => {
-                // This is a simplified version - in a real implementation, you would use proper signing
-                return new Uint8Array(keypair.secretKey.slice(0, 64));
-            };
-            return new NordUser({
-                nord,
-                address: keypair.publicKey.toBase58(),
-                walletSignFn,
-                sessionSignFn,
-                solanaPublicKey: keypair.publicKey,
-                keypair,
-                connection
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to create NordUser from private key", { cause: error });
-        }
-    }
-    /**
-     * Get the associated token account for a token mint
-     *
-     * @param mint - Token mint address
-     * @returns Associated token account address
-     * @throws {NordError} If required parameters are missing or operation fails
-     */
-    async getAssociatedTokenAccount(mint) {
-        if (!this.connection || !this.solanaPublicKey) {
-            throw new NordError_1.NordError('Connection and Solana public key are required to get associated token account');
-        }
-        try {
-            const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.solanaPublicKey);
-            try {
-                await (0, spl_token_1.getAccount)(this.connection, associatedTokenAddress);
-            }
-            catch (error) {
-                // Account doesn't exist, create it if keypair is available
-                if (this.keypair && this.bridgeClient) {
-                    await this.bridgeClient.createTokenAccountIfNeeded(mint, this.solanaPublicKey, this.keypair);
-                }
-            }
-            return associatedTokenAddress;
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to get associated token account for mint ${mint.toString()}`, { cause: error });
-        }
-    }
-    /**
-     * Deposit SPL tokens to the bridge
-     *
-     * @param amount - Amount to deposit
-     * @param tokenId - Token ID
-     * @returns Transaction signature
-     * @throws {NordError} If required parameters are missing or operation fails
-     */
-    async depositSpl(amount, tokenId) {
-        if (!this.bridgeClient || !this.keypair || !this.connection || !this.solanaPublicKey) {
-            throw new NordError_1.NordError('Bridge client, keypair, connection, and Solana public key are required for deposit');
-        }
-        try {
-            // Find the token info
-            const tokenInfo = this.splTokenInfos.find(t => t.tokenId === tokenId);
-            if (!tokenInfo) {
-                throw new NordError_1.NordError(`Token with ID ${tokenId} not found`);
-            }
-            const mint = new web3_js_1.PublicKey(tokenInfo.mint);
-            // Get the user's token account
-            const fromAccount = await this.getAssociatedTokenAccount(mint);
-            // Get the bridge's token account
-            const [authority] = await this.bridgeClient.findAuthorityPda();
-            const toAccount = await (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true);
-            // Convert amount to BN with proper decimals
-            const amountBN = (0, utils_1.toBN)(amount, tokenInfo.precision);
-            // Deposit tokens
-            return await this.bridgeClient.depositSpl({
-                amount: amountBN,
-                mint,
-                fromAccount,
-                toAccount
-            }, this.keypair);
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to deposit ${amount} of token ID ${tokenId}`, { cause: error });
-        }
-    }
-    /**
-     * Withdraw SPL tokens from the bridge
-     *
-     * @param claim - Claim data
-     * @returns Transaction signature
-     * @throws {NordError} If required parameters are missing or operation fails
-     */
-    async withdrawSpl(claim) {
-        if (!this.bridgeClient || !this.keypair || !this.connection || !this.solanaPublicKey) {
-            throw new NordError_1.NordError('Bridge client, keypair, connection, and Solana public key are required for withdrawal');
-        }
-        try {
-            // Find the token info
-            const tokenInfo = this.splTokenInfos.find(t => t.tokenId === claim.tokenId);
-            if (!tokenInfo) {
-                throw new NordError_1.NordError(`Token with ID ${claim.tokenId} not found`);
-            }
-            const mint = new web3_js_1.PublicKey(tokenInfo.mint);
-            // Get the user's token account
-            const toAccount = await this.getAssociatedTokenAccount(mint);
-            // Get the bridge's token account
-            const [authority] = await this.bridgeClient.findAuthorityPda();
-            const fromAccount = await (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true);
-            // Withdraw tokens
-            return await this.bridgeClient.withdraw({
-                claim,
-                fromAccount,
-                toAccount
-            }, this.keypair);
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to withdraw SPL tokens", { cause: error });
-        }
-    }
-    /**
-     * Get a new nonce for actions
-     *
-     * @returns Nonce as number
-     */
-    getNonce() {
-        return ++this.lastNonce;
-    }
-    /**
-     * Update account IDs for this user
-     *
-     * @throws {NordError} If the operation fails
-     */
-    async updateAccountId() {
-        try {
-            if (!this.publicKey) {
-                throw new NordError_1.NordError("Public key is required to update account ID");
-            }
-            const resp = await this.nord.getUserAccountIds({
-                pubkey: Buffer.from(this.publicKey).toString('hex')
-            });
-            this.accountIds = resp.accountIds;
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to update account ID", { cause: error });
-        }
-    }
-    /**
-     * Fetch user information including balances and orders
-     *
-     * @throws {NordError} If the operation fails
-     */
-    async fetchInfo() {
-        if (this.accountIds !== undefined) {
-            // todo:implement class
-            const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
-                const response = await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/account?account_id=${accountId}`);
-                return {
-                    accountId,
-                    ...(await response.json()),
-                };
-            }));
-            for (const accountData of accountsData) {
-                this.balances[accountData.accountId] = [];
-                for (const balance of accountData.balances) {
-                    this.balances[accountData.accountId].push({
-                        accountId: accountData.accountId,
-                        balance: balance.amount,
-                        symbol: balance.token,
-                    });
-                }
-                this.orders[accountData.accountId] = accountData.orders.map((order) => {
-                    return {
-                        orderId: order.orderId,
-                        isLong: order.side === "bid",
-                        size: order.size,
-                        price: order.price,
-                        marketId: order.marketId,
-                    };
-                });
-            }
-        }
-    }
-    /**
-     * Refresh the user's session
-     *
-     * @param sessionPk - Session public key
-     * @throws {NordError} If the operation fails
-     */
-    async refreshSession(sessionPk) {
-        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
-            userPubkey: (0, utils_1.optExpect)(this.publicKey, "No user's public key"),
-            sessionPubkey: sessionPk,
-        });
-    }
-    /**
-     * Revoke a session
-     *
-     * @param sessionId - Session ID to revoke
-     * @throws {NordError} If the operation fails
-     */
-    async revokeSession(sessionId) {
-        try {
-            await (0, actions_1.revokeSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
-                sessionId
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to revoke session ${sessionId}`, { cause: error });
-        }
-    }
-    /**
-     * Withdraw tokens from the exchange
-     *
-     * @param tokenId - Token ID to withdraw
-     * @param amount - Amount to withdraw
-     * @throws {NordError} If the operation fails
-     */
-    async withdraw(tokenId, amount) {
-        try {
-            await (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
-                sizeDecimals: (0, utils_1.findToken)(this.nord.tokens, tokenId).decimals,
-                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-                tokenId: tokenId,
-                amount,
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to withdraw ${amount} of token ID ${tokenId}`, { cause: error });
-        }
-    }
-    /**
-     * Place an order on the exchange
-     *
-     * @param params - Order parameters
-     * @returns Order ID if successful
-     * @throws {NordError} If the operation fails
-     */
-    async placeOrder(params) {
-        try {
-            const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
-            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(), {
-                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-                senderId: params.accountId,
-                sizeDecimals: market.sizeDecimals,
-                priceDecimals: market.priceDecimals,
-                marketId: params.marketId,
-                side: params.side,
-                fillMode: params.fillMode,
-                isReduceOnly: params.isReduceOnly,
-                size: params.size,
-                price: params.price,
-                quoteSize: params.quoteSize,
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to place order", { cause: error });
-        }
-    }
-    /**
-     * Cancel an order
-     *
-     * @param orderId - Order ID to cancel
-     * @param accountId - Account ID that placed the order
-     * @returns Action ID if successful
-     * @throws {NordError} If the operation fails
-     */
-    async cancelOrder(orderId, accountId) {
-        try {
-            return (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,
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to cancel order ${orderId}`, { cause: error });
-        }
-    }
-    /**
-     * Transfer tokens to another account
-     *
-     * @param params - Transfer parameters
-     * @throws {NordError} If the operation fails
-     */
-    async transferToAccount(params) {
-        try {
-            const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
-            await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
-                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-                fromAccountId: (0, utils_1.optExpect)(params.fromAccountId, "No source account"),
-                toAccountId: (0, utils_1.optExpect)(params.toAccountId, "No target account"),
-                tokenId: params.tokenId,
-                tokenDecimals: token.decimals,
-                amount: params.amount,
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to transfer tokens", { cause: error });
-        }
-    }
-    /**
-     * Create a new account
-     *
-     * @param params - Account creation parameters
-     * @returns New NordUser instance
-     * @throws {NordError} If the operation fails
-     */
-    async createAccount(params) {
-        try {
-            // Create a new keypair for the account
-            const keypair = web3_js_1.Keypair.generate();
-            // Create a new NordUser
-            const newUser = NordUser.fromPrivateKey(this.nord, keypair.secretKey, this.connection);
-            // Transfer initial funds
-            await this.transferToAccount({
-                to: newUser,
-                tokenId: params.tokenId,
-                amount: params.amount,
-                fromAccountId: (0, utils_1.optExpect)(this.accountIds?.[0], "No account ID"),
-                toAccountId: (0, utils_1.optExpect)(newUser.accountIds?.[0], "No account ID for new user"),
-            });
-            return newUser;
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to create account", { cause: error });
-        }
-    }
-}
-exports.NordUser = NordUser;

package/dist/nord/Subscriber.d.ts

@@ -1,37 +0,0 @@
-import { EventEmitter } from "events";
-import { DeltaEvent, Trades, Account, SubscriberConfig, OrderbookResponse, Trade } from "../types";
-/**
- * Subscriber class for handling WebSocket subscriptions
- */
-export declare class Subscriber {
-    streamURL: string;
-    buffer: (DeltaEvent | Trades | Account)[];
-    maxBufferLen: number;
-    /**
-     * Create a new Subscriber instance
-     * @param config Subscriber configuration
-     */
-    constructor(config: SubscriberConfig);
-    /**
-     * Subscribe to WebSocket events
-     */
-    subscribe(): void;
-}
-/**
- * Interface for orderbook subscription
- */
-export interface OrderbookSubscription extends EventEmitter {
-    on(event: 'message', listener: (data: OrderbookResponse) => void): this;
-    on(event: 'error', listener: (error: Error) => void): this;
-    close(): void;
-    removeAllListeners(event?: string): this;
-}
-/**
- * Interface for trade subscription
- */
-export interface TradeSubscription extends EventEmitter {
-    on(event: 'message', listener: (data: Trade[]) => void): this;
-    on(event: 'error', listener: (error: Error) => void): this;
-    close(): void;
-    removeAllListeners(event?: string): this;
-}

package/dist/nord/Subscriber.js

@@ -1,29 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Subscriber = void 0;
-const ws_1 = __importDefault(require("ws"));
-const utils_1 = require("../utils");
-/**
- * Subscriber class for handling WebSocket subscriptions
- */
-class Subscriber {
-    /**
-     * Create a new Subscriber instance
-     * @param config Subscriber configuration
-     */
-    constructor(config) {
-        this.streamURL = config.streamURL;
-        this.buffer = [];
-        this.maxBufferLen = config.maxBufferLen ?? utils_1.MAX_BUFFER_LEN;
-    }
-    /**
-     * Subscribe to WebSocket events
-     */
-    subscribe() {
-        const ws = new ws_1.default(this.streamURL);
-    }
-}
-exports.Subscriber = Subscriber;

package/dist/nord/actions.d.ts

@@ -1,101 +0,0 @@
-import { FillMode, Side } from "../types";
-import { BigIntValue } from "../utils";
-import Decimal from "decimal.js";
-declare function createSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
-    userPubkey: Uint8Array;
-    sessionPubkey: Uint8Array;
-    expiryTimestamp?: bigint;
-}): Promise<bigint>;
-export declare function createSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
-    userPubkey: Uint8Array;
-    sessionPubkey: Uint8Array;
-    expiryTimestamp?: bigint;
-}): Promise<bigint>;
-declare function revokeSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-}): Promise<void>;
-export declare function revokeSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-}): Promise<void>;
-declare function withdrawImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sizeDecimals: number;
-    sessionId: BigIntValue;
-    tokenId: number;
-    amount: Decimal.Value;
-}): Promise<void>;
-export declare function withdraw(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sizeDecimals: number;
-    sessionId: BigIntValue;
-    tokenId: number;
-    amount: number;
-}): Promise<void>;
-declare function placeOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    liquidateeId?: number;
-    sizeDecimals: number;
-    priceDecimals: number;
-    marketId: number;
-    side: Side;
-    fillMode: FillMode;
-    isReduceOnly: boolean;
-    size?: Decimal.Value;
-    price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
-    clientOrderId?: BigIntValue;
-}): Promise<bigint | undefined>;
-export declare function placeOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    sizeDecimals: number;
-    priceDecimals: number;
-    marketId: number;
-    side: Side;
-    fillMode: FillMode;
-    isReduceOnly: boolean;
-    size?: Decimal.Value;
-    price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
-    liquidateeId?: number;
-    clientOrderId?: BigIntValue;
-}): Promise<bigint | undefined>;
-declare function cancelOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    orderId: BigIntValue;
-    liquidateeId?: number;
-}): Promise<bigint>;
-export declare function cancelOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    orderId: BigIntValue;
-    liquidateeId?: number;
-}): Promise<bigint>;
-declare function transferImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    fromAccountId: number;
-    toAccountId?: number;
-    tokenId: number;
-    tokenDecimals: number;
-    amount: Decimal.Value;
-}): Promise<number | undefined>;
-export declare function transfer(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    fromAccountId: number;
-    toAccountId?: number;
-    tokenId: number;
-    tokenDecimals: number;
-    amount: Decimal.Value;
-}): Promise<number | undefined>;
-/**
- * For testing purposes
- */
-export declare const _private: {
-    createSessionImpl: typeof createSessionImpl;
-    revokeSessionImpl: typeof revokeSessionImpl;
-    withdrawImpl: typeof withdrawImpl;
-    placeOrderImpl: typeof placeOrderImpl;
-    cancelOrderImpl: typeof cancelOrderImpl;
-    transferImpl: typeof transferImpl;
-};
-export {};