@n1xyz/nord-ts 0.0.18-8121ed05.0 → 0.0.19

package/dist/nord/client/NordUser.js

@@ -1,595 +0,0 @@
-"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;
-    };
-})();
-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 ed = __importStar(require("@noble/ed25519"));
-const sha512_1 = require("@noble/hashes/sha512");
-ed.etc.sha512Sync = sha512_1.sha512;
-const proton_1 = require("@n1xyz/proton");
-const utils_1 = require("../../utils");
-const actions_1 = require("../api/actions");
-const NordError_1 = require("../utils/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({ address, nord, publicKey, sessionPubKey, sessionSignFn, transactionSignFn, walletSignFn, connection, sessionId, }) {
-        /** User balances by token symbol */
-        this.balances = {};
-        /** User orders by market symbol */
-        this.orders = {};
-        /** User positions by account ID */
-        this.positions = {};
-        /** User margins by account ID */
-        this.margins = {};
-        /** Last timestamp used */
-        this.lastTs = 0;
-        /** Last nonce used */
-        this.lastNonce = 0;
-        /** SPL token information */
-        this.splTokenInfos = [];
-        if (!walletSignFn) {
-            throw new NordError_1.NordError("Wallet sign function is required");
-        }
-        if (!sessionSignFn) {
-            throw new NordError_1.NordError("Session sign function is required");
-        }
-        if (!sessionPubKey) {
-            throw new NordError_1.NordError("Session public key is required");
-        }
-        try {
-            this.address = new web3_js_1.PublicKey(address);
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Invalid Solana address", { cause: error });
-        }
-        this.nord = nord;
-        this.walletSignFn = walletSignFn;
-        this.sessionSignFn = sessionSignFn;
-        this.transactionSignFn = transactionSignFn;
-        this.sessionPubKey = sessionPubKey;
-        this.publicKey = publicKey;
-        this.connection =
-            connection ||
-                new web3_js_1.Connection(nord.solanaUrl, {
-                    commitment: "confirmed",
-                });
-        // Set sessionId if provided
-        if (sessionId !== undefined) {
-            this.sessionId = sessionId;
-        }
-        // Convert tokens from info endpoint to SPLTokenInfo
-        if (this.nord.tokens && this.nord.tokens.length > 0) {
-            this.splTokenInfos = this.nord.tokens.map((token) => ({
-                mint: token.mintAddr, // Use mintAddr as mint
-                precision: token.decimals,
-                tokenId: token.tokenId,
-                name: token.symbol,
-            }));
-        }
-    }
-    /**
-     * Create a clone of this NordUser instance
-     *
-     * @returns A new NordUser instance with the same properties
-     */
-    clone() {
-        const cloned = new NordUser({
-            nord: this.nord,
-            address: this.address.toBase58(),
-            walletSignFn: this.walletSignFn,
-            sessionSignFn: this.sessionSignFn,
-            transactionSignFn: this.transactionSignFn,
-            connection: this.connection,
-            sessionPubKey: this.sessionPubKey,
-            publicKey: this.publicKey,
-        });
-        // Copy other properties
-        cloned.balances = { ...this.balances };
-        cloned.orders = { ...this.orders };
-        cloned.positions = { ...this.positions };
-        cloned.margins = { ...this.margins };
-        cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
-        cloned.sessionId = this.sessionId;
-        cloned.publicKey = this.publicKey;
-        cloned.lastTs = this.lastTs;
-        cloned.lastNonce = this.lastNonce;
-        cloned.splTokenInfos = [...this.splTokenInfos];
-        return cloned;
-    }
-    /**
-     * 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_1.keypairFromPrivateKey)(privateKey);
-            const publicKey = keypair.publicKey;
-            // Create a signing function that uses the keypair but doesn't expose it
-            const walletSignFn = async (message) => {
-                function toHex(buffer) {
-                    return Array.from(buffer)
-                        .map((byte) => byte.toString(16).padStart(2, "0"))
-                        .join("");
-                }
-                const messageBuffer = new TextEncoder().encode(toHex(message));
-                // Use ed25519 to sign the message
-                const signature = ed.sign(messageBuffer, keypair.secretKey.slice(0, 32));
-                return signature;
-            };
-            const sessionSignFn = async (message) => {
-                // Use ed25519 to sign the message
-                return ed.sign(message, keypair.secretKey.slice(0, 32));
-            };
-            // Create a transaction signing function
-            const transactionSignFn = async (transaction) => {
-                // This is a basic implementation - actual implementation would depend on the transaction type
-                if (transaction.sign) {
-                    // Solana transaction
-                    transaction.sign(keypair);
-                    return transaction;
-                }
-                // For other transaction types, would need specific implementation
-                throw new NordError_1.NordError("Unsupported transaction type for signing");
-            };
-            return new NordUser({
-                nord,
-                address: publicKey.toBase58(),
-                walletSignFn,
-                sessionSignFn,
-                transactionSignFn,
-                connection,
-                publicKey,
-                sessionPubKey: publicKey.toBytes(), // Use the public key derived from the private key as the session public key
-            });
-        }
-        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.getSolanaPublicKey()) {
-            throw new NordError_1.NordError("Solana public key is required to get associated token account");
-        }
-        try {
-            // Get the token program ID from the mint account
-            const mintAccount = await this.connection.getAccountInfo(mint);
-            if (!mintAccount) {
-                throw new NordError_1.NordError("Mint account not found");
-            }
-            const tokenProgramId = mintAccount.owner;
-            // Validate that the mint is owned by a supported SPL token program
-            if (!tokenProgramId.equals(spl_token_1.TOKEN_PROGRAM_ID) &&
-                !tokenProgramId.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
-                throw new NordError_1.NordError("Mint Account is not owned by a supported SPL token program");
-            }
-            const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.getSolanaPublicKey(), false, tokenProgramId, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
-            return associatedTokenAddress;
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to get associated token account", {
-                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) {
-        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);
-            // Convert amount to BN with proper decimals
-            const amountBN = (0, proton_1.floatToBn)(amount, tokenInfo.precision);
-            // Create deposit parameters
-            const depositParams = {
-                amount: amountBN,
-                mint,
-                fromAccount,
-            };
-            // Build the deposit transaction using proton client
-            const depositTx = await this.nord.protonClient.buildDepositTx(depositParams, this.getSolanaPublicKey(), this.connection);
-            const { blockhash } = await this.connection.getLatestBlockhash();
-            depositTx.recentBlockhash = blockhash;
-            depositTx.feePayer = this.getSolanaPublicKey();
-            const signedTx = await this.transactionSignFn(depositTx);
-            // TODO: should use `VersionedTransaction` and remove any for `transactionSignFn`,
-            // this is incredibly annoying to debug and i could've saved 30 mins.
-            const signature = await this.connection.sendRawTransaction(signedTx.serialize());
-            return signature;
-        }
-        catch (error) {
-            throw new NordError_1.NordError(`Failed to deposit ${amount} of token ID ${tokenId}`, { 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: this.publicKey.toBase58(),
-            });
-            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) {
-            const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
-                const response = await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/account/${accountId}`);
-                const accountData = (await response.json());
-                // Ensure we have the correct accountId
-                return {
-                    ...accountData,
-                    accountId,
-                };
-            }));
-            for (const accountData of accountsData) {
-                // Process balances
-                this.balances[accountData.accountId] = [];
-                for (const balance of accountData.balances) {
-                    this.balances[accountData.accountId].push({
-                        accountId: accountData.accountId,
-                        balance: balance.amount,
-                        symbol: balance.token,
-                    });
-                }
-                // Process orders
-                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,
-                    };
-                });
-                // Process positions
-                this.positions[accountData.accountId] = accountData.positions;
-                // Process margins
-                this.margins[accountData.accountId] = accountData.margins;
-            }
-        }
-    }
-    /**
-     * Refresh the user's session
-     *
-     * @throws {NordError} If the operation fails
-     */
-    async refreshSession() {
-        console.log(this.publicKey);
-        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.toBytes(), "No user's public key"),
-            sessionPubkey: this.sessionPubKey,
-        });
-    }
-    /**
-     * 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,
-            });
-        }
-    }
-    /**
-     * Checks if the session is valid
-     * @private
-     * @throws {NordError} If the session is not valid
-     */
-    checkSessionValidity() {
-        if (this.sessionId === undefined || this.sessionId === BigInt(0)) {
-            throw new NordError_1.NordError("Invalid or empty session ID. Please create or refresh your session.");
-        }
-    }
-    /**
-     * 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 {
-            this.checkSessionValidity();
-            const { actionId } = 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,
-            });
-            return { actionId };
-        }
-        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 {
-            this.checkSessionValidity();
-            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 providedAccountId - Account ID that placed the order
-     * @returns Action ID if successful
-     * @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(), {
-                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 {
-            this.checkSessionValidity();
-            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 });
-        }
-    }
-    /**
-     * Helper function to retry a promise with exponential backoff
-     *
-     * @param fn - Function to retry
-     * @param maxRetries - Maximum number of retries
-     * @param initialDelay - Initial delay in milliseconds
-     * @returns Promise result
-     */
-    async retryWithBackoff(fn, maxRetries = 3, initialDelay = 500) {
-        let retries = 0;
-        let delay = initialDelay;
-        while (true) {
-            try {
-                return await fn();
-            }
-            catch (error) {
-                if (retries >= maxRetries) {
-                    throw error;
-                }
-                // Check if error is rate limiting related
-                const isRateLimitError = error instanceof Error &&
-                    (error.message.includes("rate limit") ||
-                        error.message.includes("429") ||
-                        error.message.includes("too many requests"));
-                if (!isRateLimitError) {
-                    throw error;
-                }
-                retries++;
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    /**
-     * Get user's token balances on Solana chain using mintAddr
-     *
-     * @param options - Optional parameters
-     * @param options.includeZeroBalances - Whether to include tokens with zero balance (default: true)
-     * @param options.includeTokenAccounts - Whether to include token account addresses in the result (default: false)
-     * @param options.maxConcurrent - Maximum number of concurrent requests (default: 5)
-     * @param options.maxRetries - Maximum number of retries for rate-limited requests (default: 3)
-     * @returns Object with token balances and optional token account addresses
-     * @throws {NordError} If required parameters are missing or operation fails
-     */
-    async getSolanaBalances(options = {}) {
-        const { includeZeroBalances = true, includeTokenAccounts = false, maxConcurrent = 5, maxRetries = 3, } = options;
-        if (!this.connection || !this.getSolanaPublicKey()) {
-            throw new NordError_1.NordError("Connection and Solana public key are required to get Solana balances");
-        }
-        const balances = {};
-        const tokenAccounts = {};
-        try {
-            // Get SOL balance (native token)
-            const solBalance = await this.retryWithBackoff(() => this.connection.getBalance(this.getSolanaPublicKey()), maxRetries);
-            balances["SOL"] = solBalance / 1e9; // Convert lamports to SOL
-            if (includeTokenAccounts) {
-                tokenAccounts["SOL"] = this.getSolanaPublicKey().toString();
-            }
-            // Get SPL token balances using mintAddr from Nord tokens
-            if (this.nord.tokens && this.nord.tokens.length > 0) {
-                const tokens = this.nord.tokens.filter((token) => !!token.mintAddr);
-                // Process tokens in batches to avoid rate limiting
-                for (let i = 0; i < tokens.length; i += maxConcurrent) {
-                    const batch = tokens.slice(i, i + maxConcurrent);
-                    // Process batch in parallel
-                    const batchPromises = batch.map(async (token) => {
-                        try {
-                            const mint = new web3_js_1.PublicKey(token.mintAddr);
-                            const associatedTokenAddress = await this.retryWithBackoff(() => (0, spl_token_1.getAssociatedTokenAddress)(mint, this.getSolanaPublicKey()), maxRetries);
-                            if (includeTokenAccounts) {
-                                tokenAccounts[token.symbol] = associatedTokenAddress.toString();
-                            }
-                            try {
-                                const tokenBalance = await this.retryWithBackoff(() => this.connection.getTokenAccountBalance(associatedTokenAddress), maxRetries);
-                                const balance = Number(tokenBalance.value.uiAmount);
-                                if (balance > 0 || includeZeroBalances) {
-                                    balances[token.symbol] = balance;
-                                }
-                            }
-                            catch {
-                                // Token account might not exist yet, set balance to 0
-                                if (includeZeroBalances) {
-                                    balances[token.symbol] = 0;
-                                }
-                            }
-                        }
-                        catch (error) {
-                            console.error(`Error getting balance for token ${token.symbol}:`, error);
-                            if (includeZeroBalances) {
-                                balances[token.symbol] = 0;
-                            }
-                        }
-                    });
-                    // Wait for current batch to complete before processing next batch
-                    await Promise.all(batchPromises);
-                }
-            }
-            return includeTokenAccounts ? { balances, tokenAccounts } : { balances };
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to get Solana token balances", {
-                cause: error,
-            });
-        }
-    }
-    /**
-     * Get the Solana public key derived from the address
-     *
-     * @returns The Solana public key
-     */
-    getSolanaPublicKey() {
-        return this.address;
-    }
-}
-exports.NordUser = NordUser;

package/dist/nord/index.d.ts

@@ -1,9 +0,0 @@
-export { Nord } from "./client/Nord";
-export { NordUser } from "./client/NordUser";
-export { NordError } from "./utils/NordError";
-export * from "./api/core";
-export * from "./api/metrics";
-export * from "./api/queries";
-export * from "./api/market";
-export * from "./api/actions";
-export * from "./models/Subscriber";

package/dist/nord/index.js

@@ -1,33 +0,0 @@
-"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 });
-exports.NordError = exports.NordUser = exports.Nord = void 0;
-// Export main client classes
-var Nord_1 = require("./client/Nord");
-Object.defineProperty(exports, "Nord", { enumerable: true, get: function () { return Nord_1.Nord; } });
-var NordUser_1 = require("./client/NordUser");
-Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
-// Export utility classes
-var NordError_1 = require("./utils/NordError");
-Object.defineProperty(exports, "NordError", { enumerable: true, get: function () { return NordError_1.NordError; } });
-// Export API modules
-__exportStar(require("./api/core"), exports);
-__exportStar(require("./api/metrics"), exports);
-__exportStar(require("./api/queries"), exports);
-__exportStar(require("./api/market"), exports);
-__exportStar(require("./api/actions"), exports);
-// Export models
-__exportStar(require("./models/Subscriber"), exports);

package/dist/nord/models/Subscriber.d.ts

@@ -1,37 +0,0 @@
-import { EventEmitter } from "events";
-import { Account, DeltaEvent, OrderbookResponse, SubscriberConfig, Trade, Trades } 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;
-}