@lobstercove/lichen-sdk 1.0.0

package/dist/connection.js

@@ -0,0 +1,813 @@
+// Lichen SDK - Connection Class
+import WebSocket from 'ws';
+import { createHash } from 'crypto';
+import { TransactionBuilder } from './transaction.js';
+import { encodeTransaction, hexToBytes, bytesToHex } from './bincode.js';
+/** SHA-256 hash as Uint8Array */
+function sha256(data) {
+    return new Uint8Array(createHash('sha256').update(data).digest());
+}
+/**
+ * RPC/WebSocket connection to Lichen
+ */
+export class Connection {
+    constructor(rpcUrl, wsUrl, options) {
+        this.subscriptions = new Map();
+        this.nextId = 1;
+        this.rpcUrl = rpcUrl;
+        this.wsUrl = wsUrl;
+        this.timeoutMs = options?.timeoutMs ?? 30000;
+    }
+    /**
+     * Make an RPC call
+     */
+    async rpc(method, params = []) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await fetch(this.rpcUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: this.nextId++,
+                    method,
+                    params,
+                }),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            if (err.name === 'AbortError') {
+                throw new Error(`RPC request timed out after ${this.timeoutMs}ms: ${method}`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`RPC HTTP ${response.status}: ${text}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(`RPC Error: ${data.error.message}`);
+        }
+        return data.result;
+    }
+    // ============================================================================
+    // BASIC QUERIES
+    // ============================================================================
+    /**
+     * Get account balance
+     */
+    async getBalance(pubkey) {
+        return this.rpc('getBalance', [pubkey.toBase58()]);
+    }
+    /**
+     * Get account information
+     */
+    async getAccount(pubkey) {
+        return this.rpc('getAccount', [pubkey.toBase58()]);
+    }
+    /**
+     * Get block by slot number
+     */
+    async getBlock(slot) {
+        return this.rpc('getBlock', [slot]);
+    }
+    /**
+     * Get latest block
+     */
+    async getLatestBlock() {
+        return this.rpc('getLatestBlock');
+    }
+    /**
+     * Get current slot
+     */
+    async getSlot() {
+        const result = await this.rpc('getSlot');
+        return typeof result === 'number' ? result : result.slot;
+    }
+    /**
+     * Get recent blockhash for transactions
+     */
+    async getRecentBlockhash() {
+        const result = await this.rpc('getRecentBlockhash');
+        return typeof result === 'string' ? result : result.blockhash;
+    }
+    /**
+     * Get transaction by signature.
+     * For contract calls, response includes: return_code (u32), return_data (base64), contract_logs (string[]).
+     */
+    async getTransaction(signature) {
+        return this.rpc('getTransaction', [signature]);
+    }
+    /**
+     * Get a Merkle inclusion proof for a transaction by its signature.
+     */
+    async getTransactionProof(signature) {
+        return this.rpc('getTransactionProof', [signature]);
+    }
+    /**
+     * Verify a Merkle inclusion proof for a transaction against a root.
+     * Uses SHA-256 with domain-separated leaf (0x00) and internal (0x01) nodes.
+     *
+     * This is a pure static function — no RPC call needed.
+     */
+    static verifyTransactionProof(root, txHash, proof) {
+        // Domain-separated leaf: SHA256(0x00 || tx_hash_bytes)
+        const leafData = new Uint8Array(33);
+        leafData[0] = 0x00;
+        leafData.set(hexToBytes(txHash), 1);
+        let current = sha256(leafData);
+        for (const step of proof) {
+            const sibling = hexToBytes(step.hash);
+            const nodeData = new Uint8Array(65);
+            nodeData[0] = 0x01; // internal node domain tag
+            if (step.direction === 'left') {
+                nodeData.set(sibling, 1);
+                nodeData.set(current, 33);
+            }
+            else {
+                nodeData.set(current, 1);
+                nodeData.set(sibling, 33);
+            }
+            current = sha256(nodeData);
+        }
+        return bytesToHex(current) === root;
+    }
+    /**
+     * Send transaction
+     */
+    async sendTransaction(transaction) {
+        const txBytes = encodeTransaction(transaction);
+        const txBase64 = Buffer.from(txBytes).toString('base64');
+        const result = await this.rpc('sendTransaction', [txBase64]);
+        return typeof result === 'string' ? result : result.signature;
+    }
+    /**
+     * Get total burned LICN
+     */
+    async getTotalBurned() {
+        return this.rpc('getTotalBurned');
+    }
+    /**
+     * Get all validators
+     */
+    async getValidators() {
+        const result = await this.rpc('getValidators');
+        return result.validators;
+    }
+    /**
+     * Get performance metrics
+     */
+    async getMetrics() {
+        return this.rpc('getMetrics');
+    }
+    /**
+     * Health check
+     */
+    async health() {
+        return this.rpc('health');
+    }
+    // ============================================================================
+    // NETWORK ENDPOINTS
+    // ============================================================================
+    /**
+     * Get connected peers
+     */
+    async getPeers() {
+        const result = await this.rpc('getPeers');
+        return result.peers;
+    }
+    /**
+     * Get network information
+     */
+    async getNetworkInfo() {
+        return this.rpc('getNetworkInfo');
+    }
+    // ============================================================================
+    // VALIDATOR ENDPOINTS
+    // ============================================================================
+    /**
+     * Get detailed validator information
+     */
+    async getValidatorInfo(pubkey) {
+        return this.rpc('getValidatorInfo', [pubkey.toBase58()]);
+    }
+    /**
+     * Get validator performance metrics
+     */
+    async getValidatorPerformance(pubkey) {
+        return this.rpc('getValidatorPerformance', [pubkey.toBase58()]);
+    }
+    /**
+     * Get comprehensive chain status
+     */
+    async getChainStatus() {
+        return this.rpc('getChainStatus');
+    }
+    // ============================================================================
+    // STAKING ENDPOINTS
+    // ============================================================================
+    /**
+     * Create stake transaction
+     */
+    async stake(from, validator, amount) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.stake(from.pubkey(), validator, amount);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(from);
+        return this.sendTransaction(transaction);
+    }
+    /**
+     * Create unstake transaction
+     */
+    async unstake(from, validator, amount) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.unstake(from.pubkey(), validator, amount);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(from);
+        return this.sendTransaction(transaction);
+    }
+    /**
+     * Get staking status
+     */
+    async getStakingStatus(pubkey) {
+        return this.rpc('getStakingStatus', [pubkey.toBase58()]);
+    }
+    /**
+     * Get staking rewards
+     */
+    async getStakingRewards(pubkey) {
+        return this.rpc('getStakingRewards', [pubkey.toBase58()]);
+    }
+    // ============================================================================
+    // TRANSFER & CONTRACT ENDPOINTS
+    // ============================================================================
+    /**
+     * Transfer native LICN (spores) from one account to another.
+     *
+     * @param from - Sender keypair (signer)
+     * @param to - Recipient public key
+     * @param amount - Amount in spores (1 LICN = 1,000,000,000 spores)
+     * @returns Transaction signature
+     */
+    async transfer(from, to, amount) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.transfer(from.pubkey(), to, amount);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(from);
+        return this.sendTransaction(transaction);
+    }
+    /**
+     * Deploy a WASM smart contract.
+     *
+     * @param deployer - Deployer keypair (signer, pays deploy fee)
+     * @param code - WASM bytecode (must start with \\0asm magic, max 512 KB)
+     * @param initData - Optional initialization data passed to contract init
+     * @returns Transaction signature
+     */
+    async deployContract(deployer, code, initData = new Uint8Array(0)) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.deployContract(deployer.pubkey(), code, initData);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(deployer);
+        return this.sendTransaction(transaction);
+    }
+    /**
+     * Call a function on a deployed WASM smart contract.
+     *
+     * @param caller - Caller keypair (signer)
+     * @param contract - Contract account public key
+     * @param functionName - Name of the contract function to invoke
+     * @param args - Serialized function arguments (default: empty)
+     * @param value - Native LICN to send with the call in spores (default: 0)
+     * @returns Transaction signature
+     */
+    async callContract(caller, contract, functionName, args = new Uint8Array(0), value = 0) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.callContract(caller.pubkey(), contract, functionName, args, value);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(caller);
+        return this.sendTransaction(transaction);
+    }
+    /**
+     * Upgrade a deployed WASM smart contract (owner only).
+     *
+     * @param owner - Contract owner keypair (signer)
+     * @param contract - Contract account public key
+     * @param code - New WASM bytecode
+     * @returns Transaction signature
+     */
+    async upgradeContract(owner, contract, code) {
+        const blockhash = await this.getRecentBlockhash();
+        const instruction = TransactionBuilder.upgradeContract(owner.pubkey(), contract, code);
+        const transaction = new TransactionBuilder()
+            .add(instruction)
+            .setRecentBlockhash(blockhash)
+            .buildAndSign(owner);
+        return this.sendTransaction(transaction);
+    }
+    // ============================================================================
+    // ACCOUNT ENDPOINTS
+    // ============================================================================
+    /**
+     * Get enhanced account information
+     */
+    async getAccountInfo(pubkey) {
+        return this.rpc('getAccountInfo', [pubkey.toBase58()]);
+    }
+    /**
+     * Get transaction history
+     */
+    async getTransactionHistory(pubkey, limit = 10) {
+        return this.rpc('getTransactionHistory', [pubkey.toBase58(), limit]);
+    }
+    /**
+     * Get program accounts
+     */
+    async getProgramAccounts(programId) {
+        const result = await this.rpc('getProgramAccounts', [programId.toBase58()]);
+        return result.accounts || [];
+    }
+    /**
+     * Simulate transaction (dry run)
+     */
+    async simulateTransaction(transaction) {
+        const txBytes = encodeTransaction(transaction);
+        const txBase64 = Buffer.from(txBytes).toString('base64');
+        return this.rpc('simulateTransaction', [txBase64]);
+    }
+    /**
+     * Execute a read-only contract call without submitting a transaction.
+     */
+    async callReadonlyContract(contractId, functionName, args = new Uint8Array(), from) {
+        const params = [contractId.toBase58(), functionName, Buffer.from(args).toString('base64')];
+        if (from) {
+            params.push(from.toBase58());
+        }
+        return this.rpc('callContract', params);
+    }
+    // ============================================================================
+    // CONTRACT ENDPOINTS
+    // ============================================================================
+    /**
+     * Get contract information
+     */
+    async getContractInfo(contractId) {
+        return this.rpc('getContractInfo', [contractId.toBase58()]);
+    }
+    /**
+     * Get contract logs
+     */
+    async getContractLogs(contractId) {
+        return this.rpc('getContractLogs', [contractId.toBase58()]);
+    }
+    /**
+     * Get contract ABI/IDL (machine-readable function and event interface)
+     */
+    async getContractAbi(contractId) {
+        return this.rpc('getContractAbi', [contractId.toBase58()]);
+    }
+    /**
+     * Set/update contract ABI (owner only)
+     */
+    async setContractAbi(contractId, abi) {
+        return this.rpc('setContractAbi', [contractId.toBase58(), abi]);
+    }
+    /**
+     * Get all deployed contracts
+     */
+    async getAllContracts() {
+        return this.rpc('getAllContracts');
+    }
+    /**
+     * Get a symbol-registry entry.
+     */
+    async getSymbolRegistry(symbol) {
+        return this.rpc('getSymbolRegistry', [symbol]);
+    }
+    /**
+     * Get the complete LichenID profile for an address.
+     */
+    async getLichenIdProfile(pubkey) {
+        return this.rpc('getLichenIdProfile', [pubkey.toBase58()]);
+    }
+    /**
+     * Get the LichenID reputation summary for an address.
+     */
+    async getLichenIdReputation(pubkey) {
+        return this.rpc('getLichenIdReputation', [pubkey.toBase58()]);
+    }
+    /**
+     * Get LichenID skills for an address.
+     */
+    async getLichenIdSkills(pubkey) {
+        return this.rpc('getLichenIdSkills', [pubkey.toBase58()]);
+    }
+    /**
+     * Get LichenID vouches for an address.
+     */
+    async getLichenIdVouches(pubkey) {
+        return this.rpc('getLichenIdVouches', [pubkey.toBase58()]);
+    }
+    /**
+     * Resolve a .lichen name to its owner.
+     */
+    async resolveLichenName(name) {
+        return this.rpc('resolveLichenName', [name]);
+    }
+    /**
+     * Get premium-name auction state for a .lichen label.
+     */
+    async getNameAuction(name) {
+        return this.rpc('getNameAuction', [name]);
+    }
+    /**
+     * Get the LichenID agent directory.
+     */
+    async getLichenIdAgentDirectory(options = {}) {
+        return this.rpc('getLichenIdAgentDirectory', [options]);
+    }
+    /**
+     * Get aggregated LichenID statistics.
+     */
+    async getLichenIdStats() {
+        return this.rpc('getLichenIdStats');
+    }
+    /**
+     * Get aggregated SporePay streaming statistics.
+     */
+    async getSporePayStats() {
+        return this.rpc('getSporePayStats');
+    }
+    /**
+     * Get aggregated LichenSwap AMM statistics.
+     */
+    async getLichenSwapStats() {
+        return this.rpc('getLichenSwapStats');
+    }
+    /**
+     * Get aggregated ThallLend lending statistics.
+     */
+    async getThallLendStats() {
+        return this.rpc('getThallLendStats');
+    }
+    /**
+     * Get aggregated SporeVault yield-vault statistics.
+     */
+    async getSporeVaultStats() {
+        return this.rpc('getSporeVaultStats');
+    }
+    /**
+     * Get aggregated BountyBoard marketplace statistics.
+     */
+    async getBountyBoardStats() {
+        return this.rpc('getBountyBoardStats');
+    }
+    // ==========================================================================
+    // PROGRAM ENDPOINTS (DRAFT)
+    // ==========================================================================
+    async getProgram(programId) {
+        return this.rpc('getProgram', [programId.toBase58()]);
+    }
+    async getProgramStats(programId) {
+        return this.rpc('getProgramStats', [programId.toBase58()]);
+    }
+    async getPrograms() {
+        return this.rpc('getPrograms');
+    }
+    async getProgramCalls(programId) {
+        return this.rpc('getProgramCalls', [programId.toBase58()]);
+    }
+    async getProgramStorage(programId) {
+        return this.rpc('getProgramStorage', [programId.toBase58()]);
+    }
+    // ==========================================================================
+    // NFT ENDPOINTS (DRAFT)
+    // ==========================================================================
+    async getCollection(collectionId) {
+        return this.rpc('getCollection', [collectionId.toBase58()]);
+    }
+    async getNFT(collectionId, tokenId) {
+        return this.rpc('getNFT', [collectionId.toBase58(), tokenId]);
+    }
+    async getNFTsByOwner(owner) {
+        return this.rpc('getNFTsByOwner', [owner.toBase58()]);
+    }
+    async getNFTsByCollection(collectionId) {
+        return this.rpc('getNFTsByCollection', [collectionId.toBase58()]);
+    }
+    async getNFTActivity(collectionId, tokenId) {
+        return this.rpc('getNFTActivity', [collectionId.toBase58(), tokenId]);
+    }
+    // ============================================================================
+    // WEBSOCKET SUBSCRIPTIONS
+    // ============================================================================
+    /**
+     * Connect WebSocket
+     */
+    async connectWs() {
+        if (!this.wsUrl) {
+            throw new Error('WebSocket URL not provided');
+        }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(this.wsUrl);
+            this.ws.on('open', () => {
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                // AUDIT-FIX J-1: Guard against malformed WebSocket messages
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    console.warn('Lichen WS: ignoring non-JSON message');
+                    return;
+                }
+                if (msg.method === 'subscription') {
+                    const { subscription, result } = msg.params;
+                    const handler = this.subscriptions.get(subscription);
+                    if (handler) {
+                        handler(result);
+                    }
+                }
+            });
+            this.ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Subscribe to method
+     */
+    async subscribe(method, params = null) {
+        await this.connectWs();
+        return new Promise((resolve, reject) => {
+            const id = this.nextId++;
+            const messageHandler = (data) => {
+                // AUDIT-FIX J-1: Guard against malformed WebSocket messages
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    return; // skip non-JSON frames
+                }
+                if (msg.id === id) {
+                    clearTimeout(timeout);
+                    this.ws.off('message', messageHandler);
+                    if (msg.error) {
+                        reject(new Error(msg.error.message));
+                    }
+                    else {
+                        resolve(msg.result);
+                    }
+                }
+            };
+            const timeout = setTimeout(() => {
+                this.ws?.off('message', messageHandler);
+                reject(new Error('Subscription timeout'));
+            }, 5000);
+            this.ws.on('message', messageHandler);
+            this.ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            }));
+        });
+    }
+    /**
+     * Unsubscribe from subscription
+     */
+    async unsubscribe(method, subscriptionId) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this.subscriptions.delete(subscriptionId);
+            return false;
+        }
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const messageHandler = (data) => {
+                // AUDIT-FIX J-1: Guard against malformed WebSocket messages
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    return; // skip non-JSON frames
+                }
+                if (msg.id === id) {
+                    clearTimeout(timeout);
+                    this.ws.off('message', messageHandler);
+                    this.subscriptions.delete(subscriptionId);
+                    if (msg.error) {
+                        reject(new Error(msg.error.message));
+                    }
+                    else {
+                        resolve(msg.result);
+                    }
+                }
+            };
+            const timeout = setTimeout(() => {
+                this.ws?.off('message', messageHandler);
+                reject(new Error('Unsubscribe timeout'));
+            }, 5000);
+            this.ws.on('message', messageHandler);
+            this.ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params: subscriptionId,
+            }));
+        });
+    }
+    /**
+     * Subscribe to slot updates
+     */
+    async onSlot(callback) {
+        const subId = await this.subscribe('subscribeSlots');
+        this.subscriptions.set(subId, (data) => callback(data.slot));
+        return subId;
+    }
+    /**
+     * Unsubscribe from slots
+     */
+    async offSlot(subscriptionId) {
+        return this.unsubscribe('unsubscribeSlots', subscriptionId);
+    }
+    /**
+     * Subscribe to block updates
+     */
+    async onBlock(callback) {
+        const subId = await this.subscribe('subscribeBlocks');
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from blocks
+     */
+    async offBlock(subscriptionId) {
+        return this.unsubscribe('unsubscribeBlocks', subscriptionId);
+    }
+    /**
+     * Subscribe to transaction updates
+     */
+    async onTransaction(callback) {
+        const subId = await this.subscribe('subscribeTransactions');
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from transactions
+     */
+    async offTransaction(subscriptionId) {
+        return this.unsubscribe('unsubscribeTransactions', subscriptionId);
+    }
+    /**
+     * Subscribe to account changes
+     */
+    async onAccountChange(pubkey, callback) {
+        const subId = await this.subscribe('subscribeAccount', pubkey.toBase58());
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from account changes
+     */
+    async offAccountChange(subscriptionId) {
+        return this.unsubscribe('unsubscribeAccount', subscriptionId);
+    }
+    /**
+     * Subscribe to contract logs
+     */
+    async onLogs(callback, contractId) {
+        const params = contractId ? contractId.toBase58() : null;
+        const subId = await this.subscribe('subscribeLogs', params);
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from logs
+     */
+    async offLogs(subscriptionId) {
+        return this.unsubscribe('unsubscribeLogs', subscriptionId);
+    }
+    /**
+     * Subscribe to program updates
+     */
+    async onProgramUpdates(callback) {
+        const subId = await this.subscribe('subscribeProgramUpdates');
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from program updates
+     */
+    async offProgramUpdates(subscriptionId) {
+        return this.unsubscribe('unsubscribeProgramUpdates', subscriptionId);
+    }
+    /**
+     * Subscribe to program calls
+     */
+    async onProgramCalls(callback, programId) {
+        const params = programId ? programId.toBase58() : null;
+        const subId = await this.subscribe('subscribeProgramCalls', params);
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from program calls
+     */
+    async offProgramCalls(subscriptionId) {
+        return this.unsubscribe('unsubscribeProgramCalls', subscriptionId);
+    }
+    /**
+     * Subscribe to NFT mints
+     */
+    async onNftMints(callback, collectionId) {
+        const params = collectionId ? collectionId.toBase58() : null;
+        const subId = await this.subscribe('subscribeNftMints', params);
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from NFT mints
+     */
+    async offNftMints(subscriptionId) {
+        return this.unsubscribe('unsubscribeNftMints', subscriptionId);
+    }
+    /**
+     * Subscribe to NFT transfers
+     */
+    async onNftTransfers(callback, collectionId) {
+        const params = collectionId ? collectionId.toBase58() : null;
+        const subId = await this.subscribe('subscribeNftTransfers', params);
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from NFT transfers
+     */
+    async offNftTransfers(subscriptionId) {
+        return this.unsubscribe('unsubscribeNftTransfers', subscriptionId);
+    }
+    /**
+     * Subscribe to marketplace listings
+     */
+    async onMarketListings(callback) {
+        const subId = await this.subscribe('subscribeMarketListings');
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from marketplace listings
+     */
+    async offMarketListings(subscriptionId) {
+        return this.unsubscribe('unsubscribeMarketListings', subscriptionId);
+    }
+    /**
+     * Subscribe to marketplace sales
+     */
+    async onMarketSales(callback) {
+        const subId = await this.subscribe('subscribeMarketSales');
+        this.subscriptions.set(subId, callback);
+        return subId;
+    }
+    /**
+     * Unsubscribe from marketplace sales
+     */
+    async offMarketSales(subscriptionId) {
+        return this.unsubscribe('unsubscribeMarketSales', subscriptionId);
+    }
+    /**
+     * Close connection
+     */
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+        this.subscriptions.clear();
+    }
+}