@kaleidorg/wallet-engine 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/adapters/RgbAdapter.js

@@ -1,16 +1,24 @@
 /**
  * RGB Protocol Adapter
- * Uses kaleido-sdk to implement the protocol adapter interface.
- * Ported from rate-extension/src/protocols/adapters/RgbAdapter.ts
+ * Uses Kaleido SDK to implement the protocol adapter interface
+ */
+import { log } from "../lib/log.js";
+import { kaleidoClientManager } from "../lib/kaleido-client-manager.js";
+import { KaleidoError, APIError, NetworkError, NodeNotConfiguredError, QuoteExpiredError, InsufficientBalanceError as SdkInsufficientBalanceError, Layer as SdkLayer, } from "kaleido-sdk";
+import { ProtocolError, ConnectionError, InsufficientBalanceError, } from "../types/base.js";
+import { PROTOCOL_OPERATIONS } from "../capabilities/operations.js";
+import { resolveRgbFeeRatePolicy } from "../lib/rgb-fee-policy.js";
+import { mapPaymentStatus, mapSwapStatus } from "../lib/rgb-helpers.js";
+import { convertBtcBalance, convertNodeAssetToUnified, convertPaymentToTransaction, convertSdkBalance, convertSwapToTransaction, convertTransferToTransaction, } from "../lib/rgb-converters.js";
+/**
+ * RGB Protocol Adapter Implementation using Kaleido SDK
  */
-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.protocolName = "RGB_LN";
+        this.supportedLayers = ["RGB_L1", "RGB_LN", "BTC_L1", "BTC_LN"];
+        this.version = "1.0.0";
+        this.capabilities = PROTOCOL_OPERATIONS.RGB_LN;
         this.connected = false;
         this.config = null;
         this.swapAccessTokens = new Map();
@@ -20,66 +28,99 @@ export class RgbAdapter {
     // ========================================================================
     async connect(config) {
         const rgbConfig = config;
-        if (!rgbConfig.nodeUrl) {
-            throw new ConnectionError('Node URL is required', 'RGB');
+        const transport = rgbConfig.transport ?? "http";
+        // For HTTP a node URL is required; for NWC the connection string is. Maker
+        // is optional in both cases.
+        if (transport === "nwc") {
+            if (!rgbConfig.nwcUri) {
+                throw new ConnectionError("NWC connection string is required", "RGB_LN");
+            }
+        }
+        else if (!rgbConfig.nodeUrl) {
+            throw new ConnectionError("Node URL is required", "RGB_LN");
         }
+        log.info(`[RgbAdapter] connect() — transport=${transport} ${transport === "nwc" ? "nwc=(string)" : `nodeUrl=${rgbConfig.nodeUrl}`} makerUrl=${rgbConfig.makerUrl || "(none)"} hasApiKey=${!!rgbConfig.apiKey}`);
         try {
+            // Initialize Kaleido SDK client (maker URL is optional, transport-independent)
             kaleidoClientManager.initialize({
-                baseUrl: rgbConfig.makerUrl || '',
+                baseUrl: rgbConfig.makerUrl || "",
                 nodeUrl: rgbConfig.nodeUrl,
                 apiKey: rgbConfig.apiKey,
+                transport,
+                nwcUri: rgbConfig.nwcUri,
             });
             const client = kaleidoClientManager.getClient();
-            await client.rln.getNodeInfo();
+            log.info(`[RgbAdapter] Calling client.rln.getNodeInfo() → ${rgbConfig.nodeUrl}`);
+            const t0 = Date.now();
+            let nodeInfo;
+            try {
+                nodeInfo = await client.rln.getNodeInfo();
+                log.info(`[RgbAdapter] getNodeInfo() OK in ${Date.now() - t0}ms:`, nodeInfo);
+            }
+            catch (httpErr) {
+                const msg = httpErr instanceof Error ? httpErr.message : String(httpErr);
+                log.error(`[RgbAdapter] getNodeInfo() FAILED after ${Date.now() - t0}ms: ${msg}`, httpErr);
+                throw httpErr;
+            }
             this.config = rgbConfig;
             this.connected = true;
-            console.log('[RgbAdapter] Connected to RGB node via kaleido-sdk');
-            // Test maker connection (non-blocking)
+            log.info("[RgbAdapter] Connected to RGB node successfully via SDK");
+            // Optionally test maker connection (non-blocking)
             if (rgbConfig.makerUrl) {
                 try {
+                    log.info(`[RgbAdapter] Testing maker API → ${rgbConfig.makerUrl}`);
                     await client.maker.listAssets();
-                    console.log('[RgbAdapter] Maker API accessible');
+                    log.info("[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);
+                    log.warn("[RgbAdapter] Maker API not accessible (swaps will show error):", msg);
+                    // Don't throw - maker is optional, only needed for swaps
                 }
             }
+            else {
+                log.info("[RgbAdapter] No maker URL provided (swaps disabled)");
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            throw new ConnectionError(`Failed to connect to RGB node: ${msg}`, 'RGB', error);
+            log.error(`[RgbAdapter] connect() failed: ${msg}`);
+            throw new ConnectionError(`Failed to connect to RGB node: ${msg}`, "RGB_LN", error instanceof Error ? error : undefined);
         }
     }
     async disconnect() {
         kaleidoClientManager.reset();
         this.connected = false;
         this.config = null;
-        console.log('[RgbAdapter] Disconnected');
+        log.info("[RgbAdapter] Disconnected");
     }
     isConnected() {
         return this.connected && kaleidoClientManager.isInitialized();
     }
     async getConnectionInfo() {
         if (!this.isConnected()) {
-            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+            throw new ProtocolError("Not connected", "RGB_LN", "NOT_CONNECTED");
         }
         const info = {
-            protocol: 'RGB',
+            protocol: "RGB_LN",
             connected: true,
-            network: this.config?.network || 'regtest',
+            network: this.config?.network || "regtest",
         };
+        // Try to get node info if node is configured
         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.nodeId = nodeInfo.pubkey || "";
                 info.blockHeight = networkInfo.height || 0;
-                info.syncStatus = { synced: true, progress: 100 };
+                info.syncStatus = {
+                    synced: true,
+                    progress: 100,
+                };
             }
             catch (error) {
-                console.warn('[RgbAdapter] Could not get node info:', error);
+                log.warn("[RgbAdapter] Could not get node info:", error);
             }
         }
         return info;
@@ -89,91 +130,134 @@ export class RgbAdapter {
     // ========================================================================
     async listAssets() {
         if (!this.isConnected()) {
-            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+            throw new ProtocolError("Not connected", "RGB_LN", "NOT_CONNECTED");
         }
         const client = kaleidoClientManager.getClient();
+        // Get node assets (always works if node is connected)
         let nodeAssetsArray = [];
         if (kaleidoClientManager.hasNode()) {
             try {
                 const nodeAssets = await client.rln.listAssets();
-                const response = nodeAssets;
+                // ListAssetsResponse is an object with nia, uda, cfa arrays
+                const nodeAssetsResponse = nodeAssets;
                 nodeAssetsArray = [
-                    ...(response.nia || []),
-                    ...(response.uda || []),
-                    ...(response.cfa || []),
+                    ...(nodeAssetsResponse.nia || []),
+                    ...(nodeAssetsResponse.uda || []),
+                    ...(nodeAssetsResponse.cfa || []),
                 ];
+                log.info("[RgbAdapter] Got assets from node via SDK:", nodeAssetsArray.length);
             }
             catch (error) {
-                console.warn('[RgbAdapter] Could not get node assets:', error);
+                log.warn("[RgbAdapter] Could not get node assets:", error);
             }
         }
+        // Wallet asset lists must reflect wallet-owned node assets only.
+        // Maker-listed assets belong to market discovery and should be queried
+        // through the dedicated maker APIs used by swap flows.
         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));
+            throw new ProtocolError("No wallet assets available from node", "RGB_LN", "NO_ASSETS_AVAILABLE");
         }
-        catch {
-            // Skip BTC if balance check fails
-        }
-        assets.push(...nodeAssetsArray.map(a => this.convertNodeAssetToUnified(a)));
-        return assets;
+        return nodeAssetsArray.map((asset) => convertNodeAssetToUnified(asset));
     }
     async getAsset(assetId) {
         const assets = await this.listAssets();
-        const asset = assets.find(a => a.id === assetId || a.ticker === assetId);
+        const asset = assets.find((a) => a.id === assetId || a.ticker === assetId);
         if (!asset) {
-            throw new ProtocolError(`Asset not found: ${assetId}`, 'RGB', 'ASSET_NOT_FOUND');
+            throw new ProtocolError(`Asset not found: ${assetId}`, "RGB_LN", "ASSET_NOT_FOUND");
         }
         return asset;
     }
     async getAssetBalance(assetId) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        if (!assetId || !assetId.trim()) {
+            throw new ProtocolError("Asset ID is required", "RGB_LN", "INVALID_ASSET_ID");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            if (assetId === 'BTC' || assetId.toLowerCase() === 'btc') {
+            // Check if requesting BTC balance
+            if (assetId === "BTC" || assetId.toLowerCase() === "btc") {
                 const btcBalance = await client.rln.getBtcBalance();
-                return this.convertBtcBalance(btcBalance);
+                return convertBtcBalance(btcBalance);
+            }
+            // Get RGB asset balance
+            const balanceData = await client.rln.getAssetBalance({
+                asset_id: assetId,
+            });
+            return convertSdkBalance(balanceData);
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to get asset balance");
+        }
+    }
+    async refreshBalances() {
+        if (!kaleidoClientManager.hasNode())
+            return;
+        try {
+            const client = kaleidoClientManager.getClient();
+            const refreshTransfers = client.rln?.refreshTransfers?.bind(client.rln) ?? client.refreshTransfers?.bind(client);
+            if (refreshTransfers) {
+                await refreshTransfers({ skip_sync: false });
             }
-            const balanceData = await client.rln.getAssetBalance({ asset_id: assetId });
-            return this.convertSdkBalance(balanceData);
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to get asset balance');
+            log.warn("[RgbAdapter] Could not refresh transfers:", error);
         }
     }
-    async refreshBalances() { }
     // ========================================================================
     // Transaction Operations
     // ========================================================================
     async listTransactions(filter) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
+            // listTransfers requires asset_id for RGB on-chain transfers
             if (!filter?.asset) {
-                throw new ProtocolError('Asset ID is required for listing RGB transfers', 'RGB', 'ASSET_ID_REQUIRED');
+                throw new ProtocolError("Asset ID is required for listing RGB transfers", "RGB_LN", "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;
+            // Fetch on-chain transfers, Lightning payments AND swaps in parallel.
+            // RGB assets can move via all three rails; the asset card needs to
+            // surface all of them. listPayments() and listSwaps() return ALL
+            // entries — filter client-side by asset_id.
+            const [transfersResponse, paymentsResponse, swapsResponse] = await Promise.all([
+                client.rln.listTransfers({ asset_id: filter.asset }),
+                client.rln.listPayments().catch(() => ({ payments: [] })),
+                client.rln.listSwaps().catch(() => ({ maker: [], taker: [] })),
+            ]);
+            const transferTxs = (transfersResponse.transfers ?? []).map((transfer) => convertTransferToTransaction(transfer));
+            const paymentTxs = (paymentsResponse.payments ?? [])
+                .filter((payment) => {
+                const paymentAssetId = payment.asset_id;
+                // Match BTC payments to BTC, RGB payments to their asset_id.
+                if (filter.asset === "BTC" || filter.asset?.toLowerCase() === "btc") {
+                    return !paymentAssetId;
+                }
+                return paymentAssetId === filter.asset;
+            })
+                .map((payment) => convertPaymentToTransaction(payment));
+            const isAssetBtc = filter.asset === "BTC" || filter.asset?.toLowerCase() === "btc";
+            const matchesSwapAsset = (swap) => {
+                const fromAsset = swap.from_asset ?? null;
+                const toAsset = swap.to_asset ?? null;
+                // BTC side of a swap is encoded as a missing asset_id.
+                if (isAssetBtc)
+                    return fromAsset === null || toAsset === null;
+                return fromAsset === filter.asset || toAsset === filter.asset;
+            };
+            const swapTxs = [
+                ...(swapsResponse.maker ?? [])
+                    .filter(matchesSwapAsset)
+                    .map((swap) => convertSwapToTransaction(swap, "maker")),
+                ...(swapsResponse.taker ?? [])
+                    .filter(matchesSwapAsset)
+                    .map((swap) => convertSwapToTransaction(swap, "taker")),
+            ];
+            const merged = [...transferTxs, ...paymentTxs, ...swapTxs];
+            return merged
+                .filter((tx) => {
                 if (filter.type && tx.type !== filter.type)
                     return false;
                 if (filter.status && tx.status !== filter.status)
@@ -184,20 +268,21 @@ export class RgbAdapter {
                     return false;
                 return true;
             })
+                .sort((a, b) => b.timestamp - a.timestamp)
                 .slice(filter?.offset || 0, (filter?.offset || 0) + (filter?.limit || 100));
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to list transactions');
+            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');
+            throw new ProtocolError("Asset ID is required to look up an RGB transaction", "RGB_LN", "ASSET_ID_REQUIRED");
         }
         const transactions = await this.listTransactions({ asset: assetId });
-        const tx = transactions.find(t => t.id === txId);
+        const tx = transactions.find((t) => t.id === txId);
         if (!tx) {
-            throw new ProtocolError(`Transaction not found: ${txId}`, 'RGB', 'TX_NOT_FOUND');
+            throw new ProtocolError(`Transaction not found: ${txId}`, "RGB_LN", "TX_NOT_FOUND");
         }
         return tx;
     }
@@ -206,57 +291,62 @@ export class RgbAdapter {
     // ========================================================================
     async createInvoice(request) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
+            // Create Lightning invoice (BTC or RGB over Lightning)
+            // Build params - always include expiry_sec
             const lnInvoiceParams = {
-                expiry_sec: request.expirySeconds || 3600,
+                expiry_sec: request.expirySeconds || 3600, // Default to 1 hour
             };
-            const isRgbInvoice = request.asset && request.asset !== 'BTC' && request.asset !== 'btc';
+            // Include asset fields if provided (for RGB Lightning invoices)
+            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;
+                // The node requires amt_msat >= 3000000 for ANY RGB Lightning invoice,
+                // even zero-amount ones where asset_amount is omitted.
+                const RGB_HTLC_MIN_MSAT = 3000000; // 3000 sats in msats
                 const requestedMsat = request.amount && request.amount > 0 ? request.amount * 1000 : 0;
                 lnInvoiceParams.amt_msat = Math.max(requestedMsat, RGB_HTLC_MIN_MSAT);
             }
             else {
+                // BTC Lightning invoice — only include amt_msat if amount is provided
                 if (request.amount && request.amount > 0) {
                     lnInvoiceParams.amt_msat = request.amount * 1000;
                 }
             }
-            const lnInvoice = await client.rln.createLNInvoice(lnInvoiceParams);
+            const lnInvoice = (await client.rln.createLNInvoice(lnInvoiceParams));
             return {
-                invoice: lnInvoice.invoice ?? '',
-                paymentHash: lnInvoice.payment_hash ?? '',
+                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');
+            throw this.handleSdkError(error, "Failed to create invoice");
         }
     }
     async decodeInvoice(invoice) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            const decoded = await client.rln.decodeLNInvoice({ invoice });
+            const decoded = (await client.rln.decodeLNInvoice({ invoice }));
             const amtMsat = decoded.amt_msat;
             return {
-                paymentHash: decoded.payment_hash ?? '',
+                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 || '',
+                destination: decoded.payee_pubkey || "",
                 asset_id: decoded.asset_id ?? undefined,
                 asset_amount: decoded.asset_amount ?? undefined,
                 payment_hash: decoded.payment_hash,
@@ -264,51 +354,95 @@ export class RgbAdapter {
             };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to decode invoice');
+            throw this.handleSdkError(error, "Failed to decode invoice");
         }
     }
     async sendPayment(request) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            const sendParams = { invoice: request.invoice };
-            if (request.amount) {
-                sendParams.amt_msat = request.amount * 1000;
+            const sendParams = {
+                invoice: request.invoice,
+            };
+            // Forward `amt_msat` only for amountless invoices. Previously this
+            // truthy-check forwarded any positive `request.amount`, silently
+            // re-amounting amount-bearing invoices.
+            if (request.amount && request.amount > 0) {
+                let invoiceIsAmountless = false;
+                try {
+                    const decoded = await this.decodeInvoice(request.invoice);
+                    invoiceIsAmountless = !decoded.amount_msat && !decoded.amountMsat && !decoded.amount;
+                }
+                catch {
+                    // If decode fails, err on the side of not overriding.
+                    invoiceIsAmountless = false;
+                }
+                if (invoiceIsAmountless) {
+                    sendParams.amt_msat = request.amount * 1000;
+                }
             }
-            const result = await client.rln.sendPayment(sendParams);
+            const result = (await client.rln.sendPayment(sendParams));
             return {
-                paymentHash: result.payment_hash ?? '',
+                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),
+                status: mapPaymentStatus(result.status),
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to send payment");
+        }
+    }
+    async payKeysend(request) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const result = (await client.rln.keysend({
+                dest_pubkey: request.pubkey,
+                amt_msat: request.amount,
+                asset_id: request.assetId,
+                asset_amount: request.assetAmount,
+            }));
+            return {
+                paymentHash: result.payment_hash ?? "",
+                preimage: result.payment_preimage,
+                amount: request.amount / 1000,
+                fee: 0,
+                status: mapPaymentStatus(result.status),
                 timestamp: Date.now(),
             };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to send payment');
+            throw this.handleSdkError(error, "Failed to send keysend payment");
         }
     }
     async getPaymentStatus(paymentHash) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            const response = await client.rln.getPayment({ payment_hash: paymentHash });
+            const response = (await client.rln.getPayment({
+                payment_hash: paymentHash,
+            }));
+            // The response may be the payment directly or wrapped in a { payment } object
             const payment = (response.payment ?? response);
             return {
                 paymentHash,
-                status: this.mapPaymentStatus(payment.status),
+                status: 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');
+            throw this.handleSdkError(error, "Failed to get payment status");
         }
     }
     // ========================================================================
@@ -316,19 +450,19 @@ export class RgbAdapter {
     // ========================================================================
     async getReceiveAddress(assetId) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            const addressData = await client.rln.getAddress();
+            const addressData = (await client.rln.getAddress());
             return {
-                address: addressData.address ?? '',
-                format: 'BTC_ADDRESS',
+                address: addressData.address ?? "",
+                format: "BTC_ADDRESS",
                 asset: assetId,
             };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to get receive address');
+            throw this.handleSdkError(error, "Failed to get receive address");
         }
     }
     // ========================================================================
@@ -336,68 +470,83 @@ export class RgbAdapter {
     // ========================================================================
     async getNodeInfo() {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            return await kaleidoClientManager.getClient().rln.getNodeInfo();
+            const client = kaleidoClientManager.getClient();
+            return await client.rln.getNodeInfo();
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to get node info');
+            throw this.handleSdkError(error, "Failed to get node info");
         }
     }
     async getBtcBalance() {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "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 spendableVanilla = vanilla.spendable || 0;
+            const spendableColored = colored.spendable || 0;
+            const futureVanilla = vanilla.future || 0;
+            const futureColored = colored.future || 0;
+            const confirmed = spendableVanilla + spendableColored;
+            // `future` is the expected balance after all pending txs settle.
+            // Pending incoming = amount above spendable; pending outgoing reduces future below spendable.
+            const futureTotal = futureVanilla + futureColored;
             const unconfirmed = Math.max(futureTotal - confirmed, 0);
             return { confirmed, unconfirmed, total: futureTotal };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to get BTC balance');
+            throw this.handleSdkError(error, "Failed to get BTC balance");
         }
     }
     async listChannels() {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            const response = await kaleidoClientManager.getClient().rln.listChannels();
-            return response?.channels || response || [];
+            const client = kaleidoClientManager.getClient();
+            const response = (await client.rln.listChannels());
+            if (Array.isArray(response))
+                return response;
+            if (response && "channels" in response && Array.isArray(response.channels)) {
+                return response.channels;
+            }
+            return [];
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to list channels');
+            throw this.handleSdkError(error, "Failed to list channels");
         }
     }
     async listPayments() {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            return await kaleidoClientManager.getClient().rln.listPayments();
+            const client = kaleidoClientManager.getClient();
+            return await client.rln.listPayments();
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to list payments');
+            throw this.handleSdkError(error, "Failed to list payments");
         }
     }
     async listTransfers(options) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
+            const client = kaleidoClientManager.getClient();
             if (!options?.asset_id) {
                 return { transfers: [] };
             }
-            return await kaleidoClientManager.getClient().rln.listTransfers({ asset_id: options.asset_id });
+            return await client.rln.listTransfers({ asset_id: options.asset_id });
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to list transfers');
+            throw this.handleSdkError(error, "Failed to list transfers");
         }
     }
     // ========================================================================
@@ -405,107 +554,218 @@ export class RgbAdapter {
     // ========================================================================
     async createRgbInvoice(params) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "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,
+            const client = kaleidoClientManager.getClient();
+            const durationSeconds = (params.durationSeconds ||
+                params.duration_seconds ||
+                3600);
+            const invoiceReq = {
+                asset_id: (params.assetId || params.asset_id),
+                expiration_timestamp: Math.floor(Date.now() / 1000) + durationSeconds,
+                min_confirmations: (params.minConfirmations ||
+                    params.min_confirmations ||
+                    1),
+                witness: (params.witness ?? true),
                 ...(params.assignment ? { assignment: params.assignment } : {}),
+            };
+            return await client.rln.createRgbInvoice(invoiceReq);
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to create RGB invoice");
+        }
+    }
+    async createRgbUtxos(params = {}) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            await client.rln.createUtxos({
+                up_to: params.upTo ?? false,
+                num: params.num ?? 3,
+                size: params.size ?? 3000,
+                fee_rate: await this.resolveFeeRate(params.feeRate, "normal"),
+                skip_sync: false,
             });
+            return { success: true };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to create RGB invoice');
+            throw this.handleSdkError(error, "Failed to create RGB UTXOs");
+        }
+    }
+    async listRgbUnspents() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const response = await client.rln.listUnspents();
+            return response;
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to list unspent outputs");
+        }
+    }
+    /**
+     * Resolve a sat/vB fee rate to use for an RGB on-chain operation.
+     *
+     * Thin wrapper around {@link resolveRgbFeeRatePolicy} that provides the
+     * `estimateFn` and `network` from the live adapter state. The pure
+     * policy lives outside the class so it can be unit-tested without
+     * spinning up a kaleido client.
+     *
+     * Closes [GL #26] for the RGB adapter — previously every RGB on-chain
+     * spend used a hardcoded `1` (createUtxos) or `5` (sendAsset, sendBtc)
+     * which is a regtest-era default. On a busy mainnet mempool that's
+     * effectively "never confirms".
+     */
+    async resolveFeeRate(provided, urgency = "normal") {
+        return resolveRgbFeeRatePolicy({
+            provided,
+            urgency,
+            network: this.config?.network ?? null,
+            estimateFn: async (blocks) => {
+                try {
+                    const { fee_rate } = await this.estimateRgbFee(blocks);
+                    return fee_rate;
+                }
+                catch (err) {
+                    log.warn(`[RgbAdapter] fee estimation failed (urgency=${urgency}, blocks=${blocks}):`, err);
+                    return null;
+                }
+            },
+        });
+    }
+    async estimateRgbFee(blocks) {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const response = await client.rln.estimateFee({ blocks });
+            return { fee_rate: response?.fee_rate ?? 1 };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to estimate fee");
+        }
+    }
+    async getRgbDetailedBalance() {
+        if (!kaleidoClientManager.hasNode()) {
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
+        }
+        try {
+            const client = kaleidoClientManager.getClient();
+            const balance = await client.rln.getBtcBalance();
+            const empty = { settled: 0, future: 0, spendable: 0 };
+            return {
+                vanilla: balance?.vanilla ?? empty,
+                colored: balance?.colored ?? empty,
+            };
+        }
+        catch (error) {
+            throw this.handleSdkError(error, "Failed to get detailed BTC balance");
         }
     }
     async decodeRgbInvoice(params) {
         if (!kaleidoClientManager.hasNode()) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            return await kaleidoClientManager.getClient().rln.decodeRgbInvoice({
+            const client = kaleidoClientManager.getClient();
+            return await client.rln.decodeRgbInvoice({
                 invoice: params.invoice || params,
             });
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to decode RGB invoice');
+            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');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            return await kaleidoClientManager.getClient().rln.getInvoiceStatus(params);
+            const client = kaleidoClientManager.getClient();
+            return await client.rln.getInvoiceStatus(params);
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to get invoice status');
+            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');
+            throw new ProtocolError("Node not configured", "RGB_LN", "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({
+            const assetId = (params.assetId || params.asset_id);
+            const assignmentObj = params.assignment;
+            const amount = (params.amount ?? assignmentObj?.value);
+            // The SDK always requires an assignment; derive it from amount when not explicitly provided
+            const assignment = params.assignment ?? (amount != null ? { type: "Fungible", value: amount } : undefined);
+            const sendReq = {
                 donation: params.donation || false,
-                fee_rate: params.feeRate || params.fee_rate || 5,
+                fee_rate: await this.resolveFeeRate((params.feeRate ?? params.fee_rate), "normal"),
                 min_confirmations: 1,
                 recipient_map: {
-                    [assetId]: [{
-                            recipient_id: params.recipientId || params.recipient_id,
+                    [assetId]: [
+                        {
+                            recipient_id: (params.recipientId ||
+                                params.recipient_id),
                             assignment,
-                            transport_endpoints: params.transportEndpoints || params.transport_endpoints || [],
+                            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,
-            });
+            };
+            return await client.rln.sendRgb(sendReq);
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to send RGB asset');
+            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');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         try {
-            return await kaleidoClientManager.getClient().rln.sendBtc({
+            const client = kaleidoClientManager.getClient();
+            return await client.rln.sendBtc({
                 address: params.address,
                 amount: params.amount,
-                fee_rate: params.feeRate || 5,
+                fee_rate: await this.resolveFeeRate(params.feeRate, "normal"),
                 skip_sync: false,
             });
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to send BTC on-chain');
+            throw this.handleSdkError(error, "Failed to send BTC on-chain");
         }
     }
     // ========================================================================
-    // Swap Operations (via KaleidoSwap Maker API)
+    // Swap Operations
     // ========================================================================
     supportsSwaps() {
-        return true;
+        // Swaps via Kaleidoswap require a configured maker URL — without one
+        // every quote request errors. The UI must reflect that.
+        return !!this.config?.makerUrl;
     }
     async getSwapQuote(request) {
         if (!this.isConnected()) {
-            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+            throw new ProtocolError("Not connected", "RGB_LN", "NOT_CONNECTED");
         }
+        // Check if maker is configured
         if (!this.config?.makerUrl) {
-            throw new ProtocolError('Maker API not configured. Swaps not available in node-only mode.', 'RGB', 'MAKER_NOT_CONFIGURED');
+            throw new ProtocolError("Maker API not configured. Swaps are not available in node-only mode.", "RGB_LN", "MAKER_NOT_CONFIGURED");
         }
         try {
             const client = kaleidoClientManager.getClient();
-            const quoteResponse = await client.maker.getQuote({
+            const quoteResponse = (await client.maker.getQuote({
                 from_asset: {
                     asset_id: request.fromAsset,
                     layer: SdkLayer.RGB_LN,
@@ -516,7 +776,7 @@ export class RgbAdapter {
                     layer: SdkLayer.RGB_LN,
                     amount: request.toAmount,
                 },
-            });
+            }));
             return {
                 id: quoteResponse.rfq_id,
                 fromAsset: quoteResponse.from_asset.asset_id,
@@ -534,285 +794,119 @@ export class RgbAdapter {
                     },
                 },
                 expiresAt: quoteResponse.expires_at,
-                provider: 'Kaleidoswap',
+                provider: "Kaleidoswap",
             };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Maker API connection failed');
+            throw this.handleSdkError(error, "Maker API connection failed");
         }
     }
     async executeSwap(quote) {
         if (!this.isConnected()) {
-            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+            throw new ProtocolError("Not connected", "RGB_LN", "NOT_CONNECTED");
         }
+        // Check if maker is configured
         if (!this.config?.makerUrl) {
-            throw new ProtocolError('Maker API not configured.', 'RGB', 'MAKER_NOT_CONFIGURED');
+            throw new ProtocolError("Maker API not configured. Swaps are not available in node-only mode.", "RGB_LN", "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' },
+            const quote_request = {
+                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: '',
+                refund_address: "",
+                email: "",
             };
-            const result = await client.maker.createSwapOrder(orderRequest);
+            const result = await client.maker.createSwapOrder(quote_request);
             const swapResult = result;
-            const swapId = (swapResult.order_id ?? swapResult.id ?? '');
+            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),
+                paymentHash: (swapResult.payment_hash ?? ""),
+                status: mapSwapStatus(swapResult.status),
                 quote,
                 timestamp: Date.now(),
             };
         }
         catch (error) {
-            throw this.handleSdkError(error, 'Failed to execute swap');
+            throw this.handleSdkError(error, "Failed to execute swap");
         }
     }
     async getSwapStatus(swapId) {
         if (!this.isConnected()) {
-            throw new ProtocolError('Not connected', 'RGB', 'NOT_CONNECTED');
+            throw new ProtocolError("Not connected", "RGB_LN", "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');
+                throw new ProtocolError("Missing swap access token for status lookup", "RGB_LN", "SWAP_ACCESS_TOKEN_MISSING");
             }
-            const status = await client.maker.getSwapOrderStatus({
+            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: {},
+                status: mapSwapStatus(order.status),
+                quote: {}, // Would need to store original 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');
+            throw this.handleSdkError(error, "Failed to get swap status");
         }
     }
     // ========================================================================
-    // Private Helpers
+    // SDK ↔ unified-shape converters moved to ./converters.ts (this-free;
+    // covered by tests/unit/rgb-converters.test.ts).
     // ========================================================================
-    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);
-    }
+    // Pure mappers + formatAmount moved to ./helpers.ts (this-free; covered
+    // by tests/unit/rgb-helpers.test.ts).
     // ========================================================================
     // Error Handling
     // ========================================================================
     handleSdkError(error, context) {
         if (error instanceof NodeNotConfiguredError) {
-            throw new ProtocolError('Node not configured', 'RGB', 'NODE_NOT_CONFIGURED');
+            throw new ProtocolError("Node not configured", "RGB_LN", "NODE_NOT_CONFIGURED");
         }
         else if (error instanceof QuoteExpiredError) {
-            throw new ProtocolError('Quote expired', 'RGB', 'QUOTE_EXPIRED');
+            throw new ProtocolError("Quote expired", "RGB_LN", "QUOTE_EXPIRED");
         }
         else if (error instanceof SdkInsufficientBalanceError) {
-            throw new InsufficientBalanceError('Insufficient balance', 'RGB', 0, 0);
+            throw new InsufficientBalanceError("Insufficient balance", "RGB_LN", 0, 0);
         }
         else if (error instanceof APIError) {
-            throw new ProtocolError(`${context}: ${error.message}`, 'RGB', 'API_ERROR', error);
+            throw new ProtocolError(`${context}: ${error.message}`, "RGB_LN", "API_ERROR", error);
         }
         else if (error instanceof NetworkError) {
-            throw new ConnectionError(`${context}: Network error - ${error.message}`, 'RGB', error);
+            throw new ConnectionError(`${context}: Network error - ${error.message}`, "RGB_LN", error);
         }
         else if (error instanceof KaleidoError) {
-            throw new ProtocolError(`${context}: ${error.message}`, 'RGB', 'SDK_ERROR', error);
+            throw new ProtocolError(`${context}: ${error.message}`, "RGB_LN", "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);
+        // Default error handling
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        throw new ProtocolError(`${context}: ${msg}`, "RGB_LN", "UNKNOWN_ERROR", error instanceof Error ? error : undefined);
     }
 }
 //# sourceMappingURL=RgbAdapter.js.map