@kaleidorg/wallet-protocols 1.0.0-beta.2

package/dist/adapters/RgbAdapter.js

@@ -0,0 +1,818 @@
+/**
+ * RGB Protocol Adapter
+ * Uses kaleido-sdk to implement the protocol adapter interface.
+ * Ported from rate-extension/src/protocols/adapters/RgbAdapter.ts
+ */
+import { kaleidoClientManager } from '../lib/kaleido-client-manager';
+import { KaleidoError, APIError, NetworkError, NodeNotConfiguredError, QuoteExpiredError, InsufficientBalanceError as SdkInsufficientBalanceError, Layer as SdkLayer, } from 'kaleido-sdk';
+import { ProtocolError, ConnectionError, InsufficientBalanceError, } from '../types/base';
+export class RgbAdapter {
+    constructor() {
+        this.protocolName = 'RGB';
+        this.supportedLayers = ['RGB_L1', 'RGB_LN', 'BTC_L1', 'BTC_LN'];
+        this.version = '1.0.0';
+        this.connected = false;
+        this.config = null;
+        this.swapAccessTokens = new Map();
+    }
+    // ========================================================================
+    // Connection Management
+    // ========================================================================
+    async connect(config) {
+        const rgbConfig = config;
+        if (!rgbConfig.nodeUrl) {
+            throw new ConnectionError('Node URL is required', 'RGB');
+        }
+        try {
+            kaleidoClientManager.initialize({
+                baseUrl: rgbConfig.makerUrl || '',
+                nodeUrl: rgbConfig.nodeUrl,
+                apiKey: rgbConfig.apiKey,
+            });
+            const client = kaleidoClientManager.getClient();
+            await client.rln.getNodeInfo();
+            this.config = rgbConfig;
+            this.connected = true;
+            console.log('[RgbAdapter] Connected to RGB node via kaleido-sdk');
+            // Test maker connection (non-blocking)
+            if (rgbConfig.makerUrl) {
+                try {
+                    await client.maker.listAssets();
+                    console.log('[RgbAdapter] Maker API accessible');
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    console.warn('[RgbAdapter] Maker API not accessible (swaps will show error):', msg);
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new ConnectionError(`Failed to connect to RGB node: ${msg}`, 'RGB', error);
+        }
+    }
+    async disconnect() {
+        kaleidoClientManager.reset();
+        this.connected = false;
+        this.config = null;
+        console.log('[RgbAdapter] Disconnected');
+    }
+    isConnected() {
+        return this.connected && kaleidoClientManager.isInitialized();
+    }
+    async getConnectionInfo() {
+        if (!this.isConnected()) {
+            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+        }
+        const info = {
+            protocol: 'RGB',
+            connected: true,
+            network: this.config?.network || 'regtest',
+        };
+        if (kaleidoClientManager.hasNode()) {
+            try {
+                const client = kaleidoClientManager.getClient();
+                const nodeInfo = await client.rln.getNodeInfo();
+                const networkInfo = await client.rln.getNetworkInfo();
+                info.nodeId = nodeInfo.pubkey || '';
+                info.blockHeight = networkInfo.height || 0;
+                info.syncStatus = { synced: true, progress: 100 };
+            }
+            catch (error) {
+                console.warn('[RgbAdapter] Could not get node info:', error);
+            }
+        }
+        return info;
+    }
+    // ========================================================================
+    // Asset Operations
+    // ========================================================================
+    async listAssets() {
+        if (!this.isConnected()) {
+            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+        }
+        const client = kaleidoClientManager.getClient();
+        let nodeAssetsArray = [];
+        if (kaleidoClientManager.hasNode()) {
+            try {
+                const nodeAssets = await client.rln.listAssets();
+                const response = nodeAssets;
+                nodeAssetsArray = [
+                    ...(response.nia || []),
+                    ...(response.uda || []),
+                    ...(response.cfa || []),
+                ];
+            }
+            catch (error) {
+                console.warn('[RgbAdapter] Could not get node assets:', error);
+            }
+        }
+        if (nodeAssetsArray.length === 0) {
+            // Return at least BTC if no RGB assets
+            try {
+                const btcBalance = await client.rln.getBtcBalance();
+                return [this.createBtcAsset(btcBalance)];
+            }
+            catch {
+                return [];
+            }
+        }
+        // Add BTC as first asset
+        const assets = [];
+        try {
+            const btcBalance = await client.rln.getBtcBalance();
+            assets.push(this.createBtcAsset(btcBalance));
+        }
+        catch {
+            // Skip BTC if balance check fails
+        }
+        assets.push(...nodeAssetsArray.map(a => this.convertNodeAssetToUnified(a)));
+        return assets;
+    }
+    async getAsset(assetId) {
+        const assets = await this.listAssets();
+        const asset = assets.find(a => a.id === assetId || a.ticker === assetId);
+        if (!asset) {
+            throw new ProtocolError(`Asset not found: ${assetId}`, 'RGB', 'ASSET_NOT_FOUND');
+        }
+        return asset;
+    }
+    async getAssetBalance(assetId) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            if (assetId === 'BTC' || assetId.toLowerCase() === 'btc') {
+                const btcBalance = await client.rln.getBtcBalance();
+                return this.convertBtcBalance(btcBalance);
+            }
+            const balanceData = await client.rln.getAssetBalance({ asset_id: assetId });
+            return this.convertSdkBalance(balanceData);
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get asset balance');
+        }
+    }
+    async refreshBalances() { }
+    // ========================================================================
+    // Transaction Operations
+    // ========================================================================
+    async listTransactions(filter) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            if (!filter?.asset) {
+                throw new ProtocolError('Asset ID is required for listing RGB transfers', 'RGB', 'ASSET_ID_REQUIRED');
+            }
+            const response = await client.rln.listTransfers({ asset_id: filter.asset });
+            const transfers = response.transfers || [];
+            return transfers
+                .map(t => this.convertTransferToTransaction(t))
+                .filter(tx => {
+                if (!filter)
+                    return true;
+                if (filter.type && tx.type !== filter.type)
+                    return false;
+                if (filter.status && tx.status !== filter.status)
+                    return false;
+                if (filter.fromTimestamp && tx.timestamp < filter.fromTimestamp)
+                    return false;
+                if (filter.toTimestamp && tx.timestamp > filter.toTimestamp)
+                    return false;
+                return true;
+            })
+                .slice(filter?.offset || 0, (filter?.offset || 0) + (filter?.limit || 100));
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to list transactions');
+        }
+    }
+    async getTransaction(txId, assetId) {
+        if (!assetId) {
+            throw new ProtocolError('Asset ID is required to look up an RGB transaction', 'RGB', 'ASSET_ID_REQUIRED');
+        }
+        const transactions = await this.listTransactions({ asset: assetId });
+        const tx = transactions.find(t => t.id === txId);
+        if (!tx) {
+            throw new ProtocolError(`Transaction not found: ${txId}`, 'RGB', 'TX_NOT_FOUND');
+        }
+        return tx;
+    }
+    // ========================================================================
+    // Payment Operations
+    // ========================================================================
+    async createInvoice(request) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const lnInvoiceParams = {
+                expiry_sec: request.expirySeconds || 3600,
+            };
+            const isRgbInvoice = request.asset && request.asset !== 'BTC' && request.asset !== 'btc';
+            if (isRgbInvoice) {
+                lnInvoiceParams.asset_id = request.asset;
+                if (request.assetAmount && request.assetAmount > 0) {
+                    lnInvoiceParams.asset_amount = request.assetAmount;
+                }
+                // RGB HTLC requires minimum 3000 sats in msats
+                const RGB_HTLC_MIN_MSAT = 3000000;
+                const requestedMsat = request.amount && request.amount > 0 ? request.amount * 1000 : 0;
+                lnInvoiceParams.amt_msat = Math.max(requestedMsat, RGB_HTLC_MIN_MSAT);
+            }
+            else {
+                if (request.amount && request.amount > 0) {
+                    lnInvoiceParams.amt_msat = request.amount * 1000;
+                }
+            }
+            const lnInvoice = await client.rln.createLNInvoice(lnInvoiceParams);
+            return {
+                invoice: lnInvoice.invoice ?? '',
+                paymentHash: lnInvoice.payment_hash ?? '',
+                amount: request.amount,
+                expiresAt: Date.now() + (request.expirySeconds || 3600) * 1000,
+                description: request.description,
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to create invoice');
+        }
+    }
+    async decodeInvoice(invoice) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const decoded = await client.rln.decodeLNInvoice({ invoice });
+            const amtMsat = decoded.amt_msat;
+            return {
+                paymentHash: decoded.payment_hash ?? '',
+                amount: amtMsat != null ? amtMsat / 1000 : undefined,
+                amountMsat: amtMsat ?? undefined,
+                description: decoded.description,
+                expiresAt: decoded.expiry_sec ? Date.now() + decoded.expiry_sec * 1000 : 0,
+                destination: decoded.payee_pubkey || '',
+                asset_id: decoded.asset_id ?? undefined,
+                asset_amount: decoded.asset_amount ?? undefined,
+                payment_hash: decoded.payment_hash,
+                amount_msat: decoded.amt_msat ?? undefined,
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to decode invoice');
+        }
+    }
+    async sendPayment(request) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const sendParams = { invoice: request.invoice };
+            if (request.amount) {
+                sendParams.amt_msat = request.amount * 1000;
+            }
+            const result = await client.rln.sendPayment(sendParams);
+            return {
+                paymentHash: result.payment_hash ?? '',
+                preimage: result.payment_preimage,
+                amount: result.amount_msat ? result.amount_msat / 1000 : 0,
+                fee: result.fee_msat ? result.fee_msat / 1000 : 0,
+                status: this.mapPaymentStatus(result.status),
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to send payment');
+        }
+    }
+    async getPaymentStatus(paymentHash) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const response = await client.rln.getPayment({ payment_hash: paymentHash });
+            const payment = (response.payment ?? response);
+            return {
+                paymentHash,
+                status: this.mapPaymentStatus(payment.status),
+                amount: payment.amount_msat ? payment.amount_msat / 1000 : undefined,
+                fee: payment.fee_msat ? payment.fee_msat / 1000 : undefined,
+                timestamp: payment.created_at,
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get payment status');
+        }
+    }
+    // ========================================================================
+    // Address Operations
+    // ========================================================================
+    async getReceiveAddress(assetId) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const addressData = await client.rln.getAddress();
+            return {
+                address: addressData.address ?? '',
+                format: 'BTC_ADDRESS',
+                asset: assetId,
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get receive address');
+        }
+    }
+    // ========================================================================
+    // Node & Balance Operations
+    // ========================================================================
+    async getNodeInfo() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            return await kaleidoClientManager.getClient().rln.getNodeInfo();
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get node info');
+        }
+    }
+    async getBtcBalance() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const btcBalance = await client.rln.getBtcBalance();
+            const vanilla = btcBalance?.vanilla || {};
+            const colored = btcBalance?.colored || {};
+            const confirmed = (vanilla.spendable || 0) + (colored.spendable || 0);
+            const futureTotal = (vanilla.future || 0) + (colored.future || 0);
+            const unconfirmed = Math.max(futureTotal - confirmed, 0);
+            return { confirmed, unconfirmed, total: futureTotal };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get BTC balance');
+        }
+    }
+    async listChannels() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const response = await kaleidoClientManager.getClient().rln.listChannels();
+            return response?.channels || response || [];
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to list channels');
+        }
+    }
+    async listPayments() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            return await kaleidoClientManager.getClient().rln.listPayments();
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to list payments');
+        }
+    }
+    async listTransfers(options) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            if (!options?.asset_id) {
+                return { transfers: [] };
+            }
+            return await kaleidoClientManager.getClient().rln.listTransfers({ asset_id: options.asset_id });
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to list transfers');
+        }
+    }
+    // ========================================================================
+    // RGB-Specific Operations
+    // ========================================================================
+    async createRgbInvoice(params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const durationSec = params.durationSeconds || params.duration_seconds || 3600;
+            return await kaleidoClientManager.getClient().rln.createRgbInvoice({
+                asset_id: params.assetId || params.asset_id,
+                expiration_timestamp: Math.floor(Date.now() / 1000) + durationSec,
+                min_confirmations: params.minConfirmations || params.min_confirmations || 1,
+                witness: params.witness ?? true,
+                ...(params.assignment ? { assignment: params.assignment } : {}),
+            });
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to create RGB invoice');
+        }
+    }
+    async decodeRgbInvoice(params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            return await kaleidoClientManager.getClient().rln.decodeRgbInvoice({
+                invoice: params.invoice || params,
+            });
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to decode RGB invoice');
+        }
+    }
+    async getInvoiceStatus(params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            return await kaleidoClientManager.getClient().rln.getInvoiceStatus(params);
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get invoice status');
+        }
+    }
+    async sendAsset(params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const assetId = params.assetId || params.asset_id;
+            const amount = params.amount ?? params.assignment?.value;
+            const assignment = params.assignment ?? (amount != null ? { type: 'Fungible', value: amount } : undefined);
+            return await client.rln.sendRgb({
+                donation: params.donation || false,
+                fee_rate: params.feeRate || params.fee_rate || 5,
+                min_confirmations: 1,
+                recipient_map: {
+                    [assetId]: [{
+                            recipient_id: params.recipientId || params.recipient_id,
+                            assignment,
+                            transport_endpoints: params.transportEndpoints || params.transport_endpoints || [],
+                            ...(params.witness_data ? { witness_data: params.witness_data } : {}),
+                        }],
+                },
+                // skip_sync is a valid runtime param; cast bridges kaleido-sdk type drift.
+                skip_sync: false,
+            });
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to send RGB asset');
+        }
+    }
+    async sendBtcOnchain(params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        try {
+            return await kaleidoClientManager.getClient().rln.sendBtc({
+                address: params.address,
+                amount: params.amount,
+                fee_rate: params.feeRate || 5,
+                skip_sync: false,
+            });
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to send BTC on-chain');
+        }
+    }
+    // ========================================================================
+    // Swap Operations (via KaleidoSwap Maker API)
+    // ========================================================================
+    supportsSwaps() {
+        return true;
+    }
+    async getSwapQuote(request) {
+        if (!this.isConnected()) {
+            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+        }
+        if (!this.config?.makerUrl) {
+            throw new ProtocolError('Maker API not configured. Swaps not available in node-only mode.', 'RGB', 'MAKER_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const quoteResponse = await client.maker.getQuote({
+                from_asset: {
+                    asset_id: request.fromAsset,
+                    layer: SdkLayer.RGB_LN,
+                    amount: request.fromAmount,
+                },
+                to_asset: {
+                    asset_id: request.toAsset,
+                    layer: SdkLayer.RGB_LN,
+                    amount: request.toAmount,
+                },
+            });
+            return {
+                id: quoteResponse.rfq_id,
+                fromAsset: quoteResponse.from_asset.asset_id,
+                fromAmount: Number(quoteResponse.from_asset.amount || 0),
+                toAsset: quoteResponse.to_asset.asset_id,
+                toAmount: Number(quoteResponse.to_asset.amount || 0),
+                price: quoteResponse.price,
+                fee: {
+                    amount: quoteResponse.fee.final_fee,
+                    asset: quoteResponse.fee.fee_asset,
+                    breakdown: {
+                        baseFee: quoteResponse.fee.base_fee,
+                        variableFee: quoteResponse.fee.variable_fee,
+                        networkFee: 0,
+                    },
+                },
+                expiresAt: quoteResponse.expires_at,
+                provider: 'Kaleidoswap',
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Maker API connection failed');
+        }
+    }
+    async executeSwap(quote) {
+        if (!this.isConnected()) {
+            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+        }
+        if (!this.config?.makerUrl) {
+            throw new ProtocolError('Maker API not configured.', 'RGB', 'MAKER_NOT_CONFIGURED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const quoteAny = quote;
+            const orderRequest = {
+                rfq_id: quoteAny.rfqId || quote.id || '',
+                from_asset: { asset_id: quote.fromAsset, amount: quote.fromAmount, layer: quoteAny.fromLayer || 'RGB_LN' },
+                to_asset: { asset_id: quote.toAsset, amount: quote.toAmount, layer: quoteAny.toLayer || 'RGB_LN' },
+                receiver_address: { address: quoteAny.receiverAddress || '', format: 'BTC_ADDRESS' },
+                min_onchain_conf: 1,
+                refund_address: '',
+                email: '',
+            };
+            const result = await client.maker.createSwapOrder(orderRequest);
+            const swapResult = result;
+            const swapId = (swapResult.order_id ?? swapResult.id ?? '');
+            if (swapId && swapResult.access_token) {
+                this.swapAccessTokens.set(swapId, swapResult.access_token);
+            }
+            return {
+                swapId,
+                paymentHash: (swapResult.payment_hash ?? ''),
+                status: this.mapSwapStatus(swapResult.status),
+                quote,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to execute swap');
+        }
+    }
+    async getSwapStatus(swapId) {
+        if (!this.isConnected()) {
+            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const accessToken = this.swapAccessTokens.get(swapId);
+            if (!accessToken) {
+                throw new ProtocolError('Missing swap access token for status lookup', 'RGB', 'SWAP_ACCESS_TOKEN_MISSING');
+            }
+            const status = await client.maker.getSwapOrderStatus({
+                order_id: swapId,
+                access_token: accessToken,
+            });
+            const order = (status.order ?? status);
+            return {
+                swapId,
+                status: this.mapSwapStatus(order.status),
+                quote: {},
+                timestamp: order.created_at || Date.now(),
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, 'Failed to get swap status');
+        }
+    }
+    // ========================================================================
+    // Protocol-Specific Operations (escape hatch)
+    // ========================================================================
+    async executeProtocolOperation(operation, params) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        const client = kaleidoClientManager.getClient();
+        switch (operation) {
+            case 'initNode':
+                return client.rln.initWallet(params);
+            case 'unlockNode':
+                return client.rln.unlockWallet(params);
+            case 'lockNode':
+                return client.rln.lockWallet();
+            case 'createUtxos':
+                return client.rln.createUtxos(params);
+            case 'issueAssetNIA':
+                return client.rln.issueAssetNIA(params);
+            case 'issueAssetCFA':
+                return client.rln.issueAssetCFA(params);
+            case 'estimateFee':
+                return client.rln.estimateFee(params);
+            case 'failTransfers':
+                return client.rln.failTransfers(params);
+            case 'refreshTransfers':
+                return client.rln.refreshTransfers(params);
+            case 'sync':
+                return client.rln.syncRgbWallet();
+            case 'connectPeer':
+                return client.rln.connectPeer(params);
+            case 'disconnectPeer':
+                return client.rln.disconnectPeer(params);
+            case 'listPeers':
+                return client.rln.listPeers();
+            case 'openChannel':
+                return client.rln.openChannel(params);
+            case 'closeChannel':
+                return client.rln.closeChannel(params);
+            case 'getAssetMetadata':
+                return client.rln.getAssetMetadata(params);
+            case 'getTakerPubkey':
+                return client.rln.getTakerPubkey();
+            case 'whitelistSwap':
+                return client.rln.whitelistSwap(params);
+            case 'initSwap':
+                return client.maker.initSwap(params);
+            case 'confirmSwap':
+                return client.maker.executeSwap(params);
+            case 'listSwaps':
+                return client.rln.listSwaps();
+            case 'getSwap':
+                return client.rln.getSwap(params);
+            case 'getLspInfo':
+                return client.maker.getLspInfo();
+            case 'createLspOrder':
+                return client.maker.createLspOrder(params);
+            case 'getLspOrder':
+                return client.maker.getLspOrder(params);
+            case 'estimateLspFees':
+                return client.maker.estimateLspFees(params);
+            default:
+                throw new ProtocolError(`Unknown operation: ${operation}`, 'RGB', 'UNKNOWN_OPERATION');
+        }
+    }
+    // ========================================================================
+    // Private Helpers
+    // ========================================================================
+    createBtcAsset(btcBalance) {
+        const balance = this.convertBtcBalance(btcBalance);
+        return {
+            id: 'BTC',
+            name: 'Bitcoin (RGB Node)',
+            ticker: 'BTC',
+            precision: 8,
+            protocol: 'RGB',
+            layer: 'BTC_L1',
+            balance,
+            capabilities: {
+                canSend: true, canReceive: true, canSwap: true,
+                supportsLightning: true, supportsOnchain: true,
+            },
+        };
+    }
+    convertNodeAssetToUnified(asset) {
+        return {
+            id: asset.asset_id,
+            name: asset.name,
+            ticker: asset.ticker,
+            precision: asset.precision || 8,
+            protocol: 'RGB',
+            layer: 'RGB_LN',
+            balance: this.convertNodeBalance(asset.balance),
+            capabilities: {
+                canSend: true, canReceive: true, canSwap: false,
+                supportsLightning: true, supportsOnchain: true,
+            },
+        };
+    }
+    convertBtcBalance(btcBalance) {
+        const vanilla = btcBalance.vanilla ?? { settled: 0, future: 0, spendable: 0 };
+        return {
+            total: vanilla.settled || 0,
+            available: vanilla.spendable || 0,
+            pending: vanilla.future || 0,
+            totalDisplay: this.formatAmount(vanilla.settled || 0, 8),
+            availableDisplay: this.formatAmount(vanilla.spendable || 0, 8),
+        };
+    }
+    convertSdkBalance(balance) {
+        return {
+            total: balance.settled || 0,
+            available: balance.spendable || 0,
+            pending: balance.future || 0,
+            locked: balance.offchain_outbound || 0,
+            totalDisplay: this.formatAmount(balance.settled || 0, 8),
+            availableDisplay: this.formatAmount(balance.spendable || 0, 8),
+        };
+    }
+    convertNodeBalance(balance) {
+        const total = balance?.settled || 0;
+        const available = balance?.spendable || 0;
+        const pending = balance?.future || 0;
+        return {
+            total, available, pending,
+            locked: balance?.offchain_outbound || 0,
+            totalDisplay: this.formatAmount(total, 8),
+            availableDisplay: this.formatAmount(available, 8),
+        };
+    }
+    convertTransferToTransaction(transfer) {
+        return {
+            id: transfer.txid || `tx_${Date.now()}`,
+            type: this.mapTransferType(transfer.kind),
+            status: this.mapTransferStatus(transfer.status),
+            timestamp: transfer.created_at || Date.now(),
+            amount: transfer.amount || 0,
+            amountDisplay: this.formatAmount(transfer.amount || 0, 8),
+            fee: transfer.fee,
+            feeDisplay: this.formatAmount(transfer.fee || 0, 8),
+            asset: {},
+            from: transfer.sender,
+            to: transfer.recipient,
+            protocolData: transfer,
+        };
+    }
+    mapTransferType(kind) {
+        if (!kind)
+            return 'send';
+        if (kind.includes('receive') || kind.includes('ReceiveAsset'))
+            return 'receive';
+        if (kind.includes('send') || kind.includes('SendAsset'))
+            return 'send';
+        return 'send';
+    }
+    mapTransferStatus(status) {
+        if (!status)
+            return 'pending';
+        if (status === 'Settled' || status === 'settled')
+            return 'confirmed';
+        if (status === 'Failed' || status === 'failed')
+            return 'failed';
+        return 'pending';
+    }
+    mapPaymentStatus(status) {
+        if (!status)
+            return 'pending';
+        if (status === 'succeeded' || status === 'success' || status === 'Succeeded')
+            return 'confirmed';
+        if (status === 'failed' || status === 'Failed')
+            return 'failed';
+        return 'pending';
+    }
+    mapSwapStatus(status) {
+        if (!status)
+            return 'pending';
+        if (status === 'completed' || status === 'success' || status === 'Completed')
+            return 'confirmed';
+        if (status === 'failed' || status === 'error' || status === 'Failed')
+            return 'failed';
+        return 'pending';
+    }
+    formatAmount(amount, precision) {
+        return (amount / Math.pow(10, precision)).toFixed(precision);
+    }
+    // ========================================================================
+    // Error Handling
+    // ========================================================================
+    handleSdkError(error, context) {
+        if (error instanceof NodeNotConfiguredError) {
+            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+        }
+        else if (error instanceof QuoteExpiredError) {
+            throw new ProtocolError('Quote expired', 'RGB', 'QUOTE_EXPIRED');
+        }
+        else if (error instanceof SdkInsufficientBalanceError) {
+            throw new InsufficientBalanceError('Insufficient balance', 'RGB', 0, 0);
+        }
+        else if (error instanceof APIError) {
+            throw new ProtocolError(`${context}: ${error.message}`, 'RGB', 'API_ERROR', error);
+        }
+        else if (error instanceof NetworkError) {
+            throw new ConnectionError(`${context}: Network error - ${error.message}`, 'RGB', error);
+        }
+        else if (error instanceof KaleidoError) {
+            throw new ProtocolError(`${context}: ${error.message}`, 'RGB', 'SDK_ERROR', error);
+        }
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        throw new ProtocolError(`${context}: ${msg}`, 'RGB', 'UNKNOWN_ERROR', error instanceof Error ? error : undefined);
+    }
+}
+//# sourceMappingURL=RgbAdapter.js.map