beignet 0.2.0 → 0.4.0

package/dist/cli/beignet-node.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeignetNode = exports.defaultDataDirForMnemonic = void 0;
+exports.BeignetNode = exports.jsonToRouteHops = exports.routeHopsToJson = exports.parseScid = exports.formatScid = exports.defaultDataDirForMnemonic = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
@@ -33,19 +33,25 @@ const instance_lock_1 = require("./instance-lock");
 const crypto = __importStar(require("crypto"));
 const events_1 = require("events");
 const wallet_1 = require("../wallet");
+const logger_1 = require("../logger");
 const helpers_1 = require("../utils/helpers");
 const conversion_1 = require("../utils/conversion");
 const wallet_2 = require("../types/wallet");
+const wallet_storage_1 = require("./wallet-storage");
 const electrum_1 = require("../types/electrum");
 const lightning_node_1 = require("../lightning/node/lightning-node");
 const wallet_funding_provider_1 = require("../lightning/wallet/wallet-funding-provider");
 const sqlite_storage_1 = require("../lightning/storage/sqlite-storage");
+const encryption_1 = require("../lightning/storage/encryption");
+const scb_1 = require("../lightning/backup/scb");
+const bip39 = __importStar(require("bip39"));
 const rapid_sync_1 = require("../lightning/gossip/rapid-sync");
 const messages_1 = require("../lightning/gossip/messages");
+const types_1 = require("../lightning/gossip/types");
 const electrum_backend_1 = require("../lightning/chain/electrum-backend");
-const types_1 = require("../lightning/invoice/types");
+const types_2 = require("../lightning/invoice/types");
 const wallet_keys_1 = require("../lightning/keys/wallet-keys");
-const types_2 = require("../lightning/channel/types");
+const types_3 = require("../lightning/channel/types");
 const decode_1 = require("../lightning/invoice/decode");
 const decode_2 = require("../lightning/offer/decode");
 const errors_1 = require("./errors");
@@ -60,9 +66,73 @@ function defaultDataDirForMnemonic(mnemonic, baseDir = DEFAULT_DATA_DIR) {
     return path.join(baseDir, walletTag);
 }
 exports.defaultDataDirForMnemonic = defaultDataDirForMnemonic;
+function formatScid(scid) {
+    const { block, txIndex, outputIndex } = (0, types_1.decodeShortChannelId)(scid);
+    return `${block}x${txIndex}x${outputIndex}`;
+}
+exports.formatScid = formatScid;
+function parseScid(scid) {
+    const human = scid.match(/^(\d+)x(\d+)x(\d+)$/);
+    if (human) {
+        return (0, types_1.encodeShortChannelId)({
+            block: parseInt(human[1], 10),
+            txIndex: parseInt(human[2], 10),
+            outputIndex: parseInt(human[3], 10)
+        });
+    }
+    if (/^[0-9a-fA-F]{16}$/.test(scid)) {
+        return Buffer.from(scid, 'hex');
+    }
+    throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Invalid short channel id: ${scid} (expected <block>x<txIndex>x<output> or 16-char hex)`);
+}
+exports.parseScid = parseScid;
+function routeHopsToJson(route) {
+    return route.hops.map((hop, idx) => {
+        const feeMsat = idx < route.hops.length - 1
+            ? hop.amountToForwardMsat - route.hops[idx + 1].amountToForwardMsat
+            : 0n;
+        return {
+            pubkey: hop.pubkey.toString('hex'),
+            shortChannelId: formatScid(hop.shortChannelId),
+            amountToForwardMsat: hop.amountToForwardMsat.toString(),
+            outgoingCltvValue: hop.outgoingCltvValue,
+            feeMsat: feeMsat.toString(),
+            cltvExpiryDelta: hop.cltvExpiryDelta
+        };
+    });
+}
+exports.routeHopsToJson = routeHopsToJson;
+function jsonToRouteHops(hops) {
+    return hops.map((hop, idx) => {
+        if (!hop.pubkey || !/^[0-9a-fA-F]{66}$/.test(hop.pubkey)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Route hop ${idx}: pubkey must be a 33-byte hex string`);
+        }
+        let amountToForwardMsat;
+        try {
+            amountToForwardMsat = BigInt(hop.amountToForwardMsat);
+        }
+        catch {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Route hop ${idx}: amountToForwardMsat must be a decimal string`);
+        }
+        if (typeof hop.outgoingCltvValue !== 'number' ||
+            !Number.isInteger(hop.outgoingCltvValue) ||
+            hop.outgoingCltvValue < 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Route hop ${idx}: outgoingCltvValue must be a non-negative integer`);
+        }
+        return {
+            pubkey: Buffer.from(hop.pubkey, 'hex'),
+            shortChannelId: parseScid(hop.shortChannelId),
+            amountToForwardMsat,
+            outgoingCltvValue: hop.outgoingCltvValue
+        };
+    });
+}
+exports.jsonToRouteHops = jsonToRouteHops;
+const GRAPH_DESCRIBE_MAX_LIMIT = 500;
 const DEFAULT_ELECTRUM = {
     mainnet: { host: 'fulcrum.bitkit.blocktank.to', port: 8900, useTls: true },
     testnet: { host: 'electrum.blockstream.info', port: 60002, useTls: true },
+    signet: { host: 'mempool.space', port: 60602, useTls: true },
     regtest: { host: '34.65.252.32', port: 18483, useTls: false }
 };
 async function resolveHostToIPv4(host) {
@@ -76,13 +146,6 @@ async function resolveHostToIPv4(host) {
         return host;
     }
 }
-const LOG_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    silent: 4
-};
 class BeignetNode extends events_1.EventEmitter {
     on(event, listener) {
         return super.on(event, listener);
@@ -106,18 +169,25 @@ class BeignetNode extends events_1.EventEmitter {
         this._failoverInProgress = false;
         this._connectTimeoutMs = 15000;
         this._dailySpentSats = 0;
+        this._dailySpentLightningSats = 0;
+        this._dailySpentOnchainSats = 0;
         this._dailySpendResetTime = 0;
         this._pendingSpendSats = 0;
         this._draining = false;
+        this.peerStorageEnabled = true;
+        this._peerRetrievedScb = null;
         this.mnemonic = mnemonic;
         this.networkName = networkName;
         this.dataDir = dataDir;
     }
     log(level, message, data) {
-        if (LOG_PRIORITY[level] < LOG_PRIORITY[this.logLevel])
+        if (logger_1.LOG_LEVEL_PRIORITY[level] < logger_1.LOG_LEVEL_PRIORITY[this.logLevel])
             return;
         const entry = { level, message, data, timestamp: Date.now() };
         this.emit('log', entry);
+        if (this.logger && level !== 'silent') {
+            this.logger[level](message, data);
+        }
     }
     static async create(opts = {}) {
         const mnemonic = opts.mnemonic || (0, helpers_1.generateMnemonic)();
@@ -131,7 +201,10 @@ class BeignetNode extends events_1.EventEmitter {
     async init(opts) {
         if (opts.logLevel)
             this.logLevel = opts.logLevel;
+        if (opts.logger)
+            this.logger = opts.logger;
         this.autoGossipSync = opts.autoGossipSync ?? true;
+        this.peerStorageEnabled = opts.peerStorageEnabled ?? true;
         this.rapidGossipSync = opts.rapidGossipSync ?? true;
         this.rapidGossipSyncUrl = opts.rapidGossipSyncUrl;
         const networkName = this.networkName;
@@ -149,7 +222,11 @@ class BeignetNode extends events_1.EventEmitter {
         const beignetNetwork = this.toBeignetNetwork(networkName);
         const lnNetwork = this.toLnNetwork(networkName);
         const coinType = this.toCoinType(networkName);
-        const chainHash = networkName === 'regtest' ? types_2.REGTEST_CHAIN_HASH : types_2.BITCOIN_CHAIN_HASH;
+        let chainHash = types_3.BITCOIN_CHAIN_HASH;
+        if (networkName === 'regtest')
+            chainHash = types_3.REGTEST_CHAIN_HASH;
+        if (networkName === 'signet')
+            chainHash = types_3.SIGNET_CHAIN_HASH;
         if (!opts.allowMultipleInstances) {
             const lockPath = path.join(this.dataDir, `${networkName}.lock`);
             try {
@@ -169,16 +246,24 @@ class BeignetNode extends events_1.EventEmitter {
         if (!opts.dataDir) {
             const legacyDb = path.join(DEFAULT_DATA_DIR, `${networkName}.db`);
             if (fs.existsSync(legacyDb) && !fs.existsSync(dbPath)) {
-                console.warn(`[beignet] Found a legacy shared database at ${legacyDb}. ` +
+                const legacyMsg = `[beignet] Found a legacy shared database at ${legacyDb}. ` +
                     `Storage is now per-wallet (${dbPath}), so it is no longer auto-loaded. ` +
-                    `If it held this wallet's channels, re-run with dataDir set to "${DEFAULT_DATA_DIR}" to use it.`);
+                    `If it held this wallet's channels, re-run with dataDir set to "${DEFAULT_DATA_DIR}" to use it.`;
+                this.log('warn', legacyMsg);
+                if (!this.logger) {
+                    console.warn(legacyMsg);
+                }
             }
         }
+        let encryptionKey;
+        if (opts.storageEncryption ?? true) {
+            encryptionKey = (0, encryption_1.deriveStorageKey)(bip39.mnemonicToSeedSync(this.mnemonic));
+        }
         this.storage = new sqlite_storage_1.SqliteStorage(dbPath, (err) => {
             this.log('warn', 'Skipped corrupted storage row during load', {
                 error: err instanceof Error ? err.message : String(err)
             });
-        });
+        }, encryptionKey ? { encryptionKey } : undefined);
         this.storage.open();
         const electrumServer = {
             host: electrumHost,
@@ -189,12 +274,18 @@ class BeignetNode extends events_1.EventEmitter {
         const walletResult = await wallet_1.Wallet.create({
             mnemonic: this.mnemonic,
             network: beignetNetwork,
+            ...(opts.feeEstimationSource
+                ? { feeEstimationSource: opts.feeEstimationSource }
+                : {}),
             electrumOptions: {
                 net,
                 tls,
                 servers: electrumServer
             },
-            disableMessagesOnCreate: true
+            disableMessagesOnCreate: true,
+            ...(this.logger ? { logger: this.logger } : {}),
+            rbf: true,
+            storage: (0, wallet_storage_1.createWalletStorage)(this.storage)
         });
         if (walletResult.isErr()) {
             throw new errors_1.BeignetError('WALLET_CREATE_FAILED', walletResult.error.message);
@@ -293,10 +384,16 @@ class BeignetNode extends events_1.EventEmitter {
             announcedAddresses,
             fundingProvider,
             preferAnchors: opts.preferAnchors,
+            largeChannels: opts.largeChannels,
             chainBackend: electrumBackend,
             feeEstimator: electrumBackend,
+            logger: this.logger,
             sweepDestinationScript,
-            socks5Proxy
+            socks5Proxy,
+            peerStorageEnabled: this.peerStorageEnabled,
+            autoRebalance: opts.autoRebalance,
+            autoTuneFees: opts.autoTuneFees,
+            watchtowers: opts.watchtowers
         });
         if (!sweepDestinationScript) {
             this.scheduleSweepAddressRefresh();
@@ -344,13 +441,79 @@ class BeignetNode extends events_1.EventEmitter {
         this.node.on('channel:ready', (data) => {
             const channelId = data.channelId.toString('hex');
             this.log('info', 'Channel ready', { channelId });
+            this.refreshStaticChannelBackup();
             this.emit('channel:ready', { channelId });
         });
         this.node.on('channel:closed', (data) => {
             const channelId = data.channelId.toString('hex');
             this.log('info', 'Channel closed', { channelId });
+            this.refreshStaticChannelBackup();
             this.emit('channel:closed', { channelId });
         });
+        this.node.on('channel:resolved', () => {
+            this.refreshStaticChannelBackup();
+        });
+        this.node.on('channel:opening', (data) => {
+            const channelId = data.channelId.toString('hex');
+            const fundingTxid = data.fundingTxid.toString('hex');
+            this.log('info', 'Channel opening', { channelId, fundingTxid });
+            this.emit('channel:opening', { channelId, fundingTxid });
+        });
+        this.node.on('channel:pending-close', (data) => {
+            const channelId = data.channelId.toString('hex');
+            this.log('info', 'Channel pending close', {
+                channelId,
+                initiator: data.initiator
+            });
+            this.emit('channel:pending-close', {
+                channelId,
+                initiator: data.initiator
+            });
+        });
+        this.node.on('channel:force-closing', (data) => {
+            const channelId = data.channelId.toString('hex');
+            this.log('warn', 'Channel force-closing', {
+                channelId,
+                initiator: data.initiator
+            });
+            this.emit('channel:force-closing', {
+                channelId,
+                initiator: data.initiator
+            });
+        });
+        this.node.on('invoice:settled', (data) => {
+            const info = {
+                paymentHash: data.paymentHash.toString('hex'),
+                bolt11: data.bolt11,
+                amountSats: Number(data.amountMsat / 1000n)
+            };
+            this.log('info', 'Invoice settled', {
+                paymentHash: info.paymentHash,
+                amountSats: info.amountSats
+            });
+            this.emit('invoice:settled', info);
+        });
+        this.node.on('htlc:forwarded', (data) => {
+            this.emit('htlc:forwarded', {
+                inChannelId: data.inChannelId.toString('hex'),
+                outChannelId: data.outChannelId.toString('hex'),
+                amountInMsat: data.amountInMsat.toString(),
+                amountOutMsat: data.amountOutMsat.toString(),
+                feeMsat: data.feeMsat.toString()
+            });
+        });
+        this.node.on('htlc:fulfilled', (data) => {
+            this.emit('htlc:fulfilled', {
+                channelId: data.channelId.toString('hex'),
+                htlcId: data.htlcId.toString()
+            });
+        });
+        this.node.on('htlc:failed', (data) => {
+            this.emit('htlc:failed', {
+                channelId: data.channelId.toString('hex'),
+                htlcId: data.htlcId.toString()
+            });
+        });
         this.node.on('peer:connect', (pubkey) => {
             this.log('debug', 'Peer connected', { pubkey });
             if (this.autoGossipSync) {
@@ -378,6 +541,10 @@ class BeignetNode extends events_1.EventEmitter {
             this.log('info', 'Node ready');
             this.emit('node:ready');
         });
+        this.node.on('peer_storage:retrieved', (peerPubkey, blob) => this.handleRetrievedPeerStorage(peerPubkey, blob));
+        if (this.peerStorageEnabled) {
+            this.refreshStaticChannelBackup();
+        }
         try {
             await electrumBackend.estimateFee(6);
         }
@@ -489,6 +656,21 @@ class BeignetNode extends events_1.EventEmitter {
     getMnemonic() {
         return this.mnemonic;
     }
+    signMessage(message) {
+        if (typeof message !== 'string' || message.length === 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'message required');
+        }
+        return {
+            signature: this.node.signMessage(message),
+            pubkey: this.node.getNodeId()
+        };
+    }
+    verifyMessage(message, signature) {
+        if (typeof message !== 'string' || typeof signature !== 'string') {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'message and signature required');
+        }
+        return this.node.verifyMessage(message, signature);
+    }
     getBalance() {
         const onchain = this.wallet.getBalance();
         const lnBalance = this.node.getBalance();
@@ -498,9 +680,9 @@ class BeignetNode extends events_1.EventEmitter {
     }
     getPendingCloseBalanceSats() {
         const recovering = new Set([
-            types_2.ChannelState.FORCE_CLOSED,
-            types_2.ChannelState.SHUTTING_DOWN,
-            types_2.ChannelState.NEGOTIATING_CLOSING
+            types_3.ChannelState.FORCE_CLOSED,
+            types_3.ChannelState.SHUTTING_DOWN,
+            types_3.ChannelState.NEGOTIATING_CLOSING
         ]);
         let totalMsat = 0n;
         for (const ch of this.node.listChannels()) {
@@ -513,7 +695,7 @@ class BeignetNode extends events_1.EventEmitter {
     getErroredBalanceSats() {
         let totalMsat = 0n;
         for (const ch of this.node.listChannels()) {
-            if (ch.state === types_2.ChannelState.ERRORED) {
+            if (ch.state === types_3.ChannelState.ERRORED) {
                 totalMsat += ch.localBalanceMsat;
             }
         }
@@ -584,16 +766,96 @@ class BeignetNode extends events_1.EventEmitter {
         return result.value.addressIndex.address;
     }
     async sendOnchain(address, amountSats, satsPerVbyte) {
+        this._checkSpendLimit(amountSats);
         const result = await this.wallet.send({
             address,
             amount: amountSats,
             broadcast: false,
+            rbf: this.wallet.rbf,
             ...(satsPerVbyte !== undefined ? { satsPerByte: satsPerVbyte } : {})
         });
         if (result.isErr()) {
             throw new errors_1.BeignetError('SEND_FAILED', result.error.message);
         }
-        const hex = result.value;
+        if (this._dailySpendLimitSats === undefined) {
+            return this._broadcastRawTx(result.value);
+        }
+        const totalSats = this._builtOnchainTotalSats(amountSats);
+        try {
+            this._checkSpendLimit(totalSats);
+        }
+        catch (e) {
+            await this.wallet.resetSendTransaction();
+            throw e;
+        }
+        this._pendingSpendSats += totalSats;
+        try {
+            const info = await this._broadcastRawTx(result.value);
+            this._recordSpend(totalSats, 'onchain');
+            return info;
+        }
+        finally {
+            this._pendingSpendSats -= totalSats;
+        }
+    }
+    async buildPsbt(outputs, satsPerVbyte) {
+        if (!Array.isArray(outputs) || outputs.length === 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'outputs array required');
+        }
+        for (const output of outputs) {
+            if (!output?.address || typeof output.amountSats !== 'number') {
+                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'each output requires address and amountSats');
+            }
+        }
+        this._validateFeeRate(satsPerVbyte);
+        const result = await this.wallet.buildPsbt({
+            txs: outputs.map((o) => ({ address: o.address, amount: o.amountSats })),
+            rbf: this.wallet.rbf,
+            ...(satsPerVbyte !== undefined ? { satsPerByte: satsPerVbyte } : {})
+        });
+        if (result.isErr()) {
+            throw new errors_1.BeignetError('PSBT_BUILD_FAILED', result.error.message);
+        }
+        const built = result.value;
+        return {
+            psbtBase64: built.psbtBase64,
+            feeSats: built.fee,
+            vsizeEstimate: built.vsizeEstimate,
+            satsPerVbyte: built.satsPerByte,
+            inputs: built.inputs.map((input) => ({
+                txid: input.tx_hash,
+                vout: input.tx_pos,
+                address: input.address,
+                valueSats: input.value,
+                path: input.path
+            })),
+            outputs: built.outputs.map((output) => ({
+                address: output.address,
+                valueSats: output.value
+            }))
+        };
+    }
+    importSignedPsbt(psbtBase64) {
+        if (!psbtBase64 || typeof psbtBase64 !== 'string') {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'psbtBase64 required');
+        }
+        const result = this.wallet.importSignedPsbt(psbtBase64);
+        if (result.isErr()) {
+            throw new errors_1.BeignetError('PSBT_IMPORT_FAILED', result.error.message);
+        }
+        return { txid: result.value.txid, txHex: result.value.txHex };
+    }
+    combinePsbts(psbts) {
+        if (!Array.isArray(psbts) || psbts.length < 2) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'psbts array with at least two entries required');
+        }
+        const result = this.wallet.combinePsbts(psbts);
+        if (result.isErr()) {
+            throw new errors_1.BeignetError('PSBT_COMBINE_FAILED', result.error.message);
+        }
+        return { psbtBase64: result.value };
+    }
+    async _broadcastRawTx(hex) {
         const bitcoin = await Promise.resolve().then(() => __importStar(require('bitcoinjs-lib')));
         const tx = bitcoin.Transaction.fromHex(hex);
         const broadcastRes = await this.wallet.electrum.broadcastTransaction({
@@ -604,15 +866,217 @@ class BeignetNode extends events_1.EventEmitter {
         }
         return { txid: tx.getId(), hex };
     }
+    _validateFeeRate(satsPerVbyte, required = false) {
+        if (satsPerVbyte === undefined) {
+            if (required) {
+                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'satsPerVbyte required');
+            }
+            return;
+        }
+        if (typeof satsPerVbyte !== 'number' ||
+            !Number.isFinite(satsPerVbyte) ||
+            satsPerVbyte <= 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'satsPerVbyte must be a positive number');
+        }
+    }
+    _validateTxid(txid) {
+        if (typeof txid !== 'string' || !/^[0-9a-fA-F]{64}$/.test(txid)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'txid must be a 64-character hex string');
+        }
+    }
+    async sendMaxOnchain(address, satsPerVbyte) {
+        if (!address ||
+            typeof address !== 'string' ||
+            !this.wallet.validateAddress(address)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Invalid ${this.networkName} address: ${address}`);
+        }
+        this._validateFeeRate(satsPerVbyte);
+        const result = await this.wallet.sendMax({
+            address,
+            satsPerByte: satsPerVbyte ?? this.wallet.feeEstimates.normal,
+            rbf: this.wallet.rbf,
+            broadcast: false
+        });
+        if (result.isErr()) {
+            throw new errors_1.BeignetError('SEND_FAILED', result.error.message);
+        }
+        if (this._dailySpendLimitSats === undefined) {
+            return this._broadcastRawTx(result.value);
+        }
+        const totalSats = this.wallet.transaction.getTransactionInputValue({
+            inputs: this.wallet.transaction.data.inputs
+        });
+        if (totalSats <= 0) {
+            await this.wallet.resetSendTransaction();
+            throw new errors_1.BeignetError('SPENDING_LIMIT_EXCEEDED', 'Unable to determine the swept amount for the daily spend limit check; refusing to send');
+        }
+        try {
+            this._checkSpendLimit(totalSats);
+        }
+        catch (e) {
+            await this.wallet.resetSendTransaction();
+            throw e;
+        }
+        this._pendingSpendSats += totalSats;
+        try {
+            const info = await this._broadcastRawTx(result.value);
+            this._recordSpend(totalSats, 'onchain');
+            return info;
+        }
+        finally {
+            this._pendingSpendSats -= totalSats;
+        }
+    }
+    async bumpFeeOnchain(txid, satsPerVbyte) {
+        this._validateTxid(txid);
+        this._validateFeeRate(satsPerVbyte, true);
+        const can = this.wallet.canBoost(txid);
+        if (!can.rbf) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, can.cpfp
+                ? `Transaction ${txid} cannot be replaced via RBF; use POST /tx/boost (CPFP) instead`
+                : `Transaction ${txid} is not boostable (unknown, already confirmed, or balance too low)`);
+        }
+        return this._boostRbf(txid, satsPerVbyte);
+    }
+    async boostOnchain(txid, satsPerVbyte) {
+        this._validateTxid(txid);
+        this._validateFeeRate(satsPerVbyte);
+        const can = this.wallet.canBoost(txid);
+        if (!can.canBoost) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, `Transaction ${txid} is not boostable (unknown, already confirmed, or balance too low)`);
+        }
+        if (can.rbf) {
+            try {
+                return await this._boostRbf(txid, satsPerVbyte);
+            }
+            catch (e) {
+                const rbfImpossible = e instanceof errors_1.BeignetError &&
+                    e.code === errors_1.BeignetErrorCode.NOT_BOOSTABLE;
+                if (!(rbfImpossible && can.cpfp))
+                    throw e;
+            }
+        }
+        return this._boostCpfp(txid, satsPerVbyte);
+    }
+    async _boostRbf(txid, satsPerVbyte) {
+        const setup = await this.wallet.transaction.setupRbf({ txid });
+        if (setup.isErr()) {
+            await this.wallet.resetSendTransaction();
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, setup.error.message);
+        }
+        try {
+            if (satsPerVbyte !== undefined) {
+                const feeRes = this.wallet.transaction.updateFee({
+                    satsPerByte: satsPerVbyte
+                });
+                if (feeRes.isErr()) {
+                    throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, feeRes.error.message);
+                }
+            }
+            const original = this.wallet.unconfirmedTransactions[txid] ??
+                this.wallet.transactions[txid];
+            const originalFeeSats = original ? (0, conversion_1.btcToSats)(original.fee) : 0;
+            const newFeeSats = this.wallet.transaction.data.fee;
+            if (newFeeSats <= originalFeeSats) {
+                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Replacement fee ${newFeeSats} sats does not exceed the original fee ${originalFeeSats} sats; raise satsPerVbyte`);
+            }
+            const createRes = await this.wallet.transaction.createTransaction();
+            if (createRes.isErr()) {
+                throw new errors_1.BeignetError('SEND_FAILED', createRes.error.message);
+            }
+            const info = await this._broadcastRawTx(createRes.value.hex);
+            await this._recordBoost(txid, info.txid, wallet_2.EBoostType.rbf, newFeeSats);
+            return {
+                ...info,
+                boostType: 'rbf',
+                feeSats: newFeeSats,
+                originalTxid: txid
+            };
+        }
+        finally {
+            await this.wallet.resetSendTransaction();
+        }
+    }
+    async _boostCpfp(txid, satsPerVbyte) {
+        const setup = await this.wallet.transaction.setupCpfp({
+            txid,
+            ...(satsPerVbyte !== undefined ? { satsPerByte: satsPerVbyte } : {})
+        });
+        if (setup.isErr()) {
+            await this.wallet.resetSendTransaction();
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, setup.error.message);
+        }
+        try {
+            const feeSats = setup.value.fee;
+            const createRes = await this.wallet.transaction.createTransaction();
+            if (createRes.isErr()) {
+                throw new errors_1.BeignetError('SEND_FAILED', createRes.error.message);
+            }
+            const info = await this._broadcastRawTx(createRes.value.hex);
+            await this._recordBoost(txid, info.txid, wallet_2.EBoostType.cpfp, feeSats);
+            return {
+                ...info,
+                boostType: 'cpfp',
+                feeSats,
+                originalTxid: txid
+            };
+        }
+        finally {
+            await this.wallet.resetSendTransaction();
+        }
+    }
+    async _recordBoost(oldTxId, newTxId, type, fee) {
+        const res = await this.wallet.addBoostedTransaction({
+            oldTxId,
+            newTxId,
+            type,
+            fee
+        });
+        if (res.isErr()) {
+            this.log('warn', 'Failed to record boosted transaction', {
+                oldTxId,
+                newTxId,
+                error: res.error.message
+            });
+        }
+    }
+    listBoostableTransactions() {
+        const { rbf, cpfp } = this.wallet.getBoostableTransactions();
+        return {
+            rbf: rbf.map((tx) => this.toOnchainTxInfo(tx)),
+            cpfp: cpfp.map((tx) => this.toOnchainTxInfo(tx))
+        };
+    }
+    async consolidateUtxos(satsPerVbyte) {
+        this._validateFeeRate(satsPerVbyte);
+        const utxoCount = this.wallet
+            .listUtxos()
+            .filter((u) => !this.wallet.isUtxoFrozen(u.tx_hash, u.tx_pos)).length;
+        if (utxoCount < 2) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOTHING_TO_CONSOLIDATE, `Nothing to consolidate: wallet has ${utxoCount} spendable UTXO(s), need at least 2`);
+        }
+        const address = await this.getNewAddress();
+        const result = await this.wallet.sendMax({
+            address,
+            satsPerByte: satsPerVbyte ?? this.wallet.feeEstimates.normal,
+            rbf: this.wallet.rbf,
+            broadcast: false
+        });
+        if (result.isErr()) {
+            throw new errors_1.BeignetError('SEND_FAILED', result.error.message);
+        }
+        const feeSats = this.wallet.transaction.data.fee;
+        const info = await this._broadcastRawTx(result.value);
+        return { ...info, utxosConsolidated: utxoCount, address, feeSats };
+    }
     async refreshWallet() {
         const result = await this.wallet.refreshWallet({});
         if (result.isErr()) {
             throw new errors_1.BeignetError('REFRESH_FAILED', result.error.message);
         }
     }
-    listOnchainTransactions() {
-        return Object.values(this.wallet.transactions)
-            .map((tx) => ({
+    toOnchainTxInfo(tx) {
+        return {
             txid: tx.txid,
             type: tx.type === wallet_2.EPaymentType.sent
                 ? 'sent'
@@ -627,7 +1091,11 @@ class BeignetNode extends events_1.EventEmitter {
             ...(tx.confirmTimestamp !== undefined
                 ? { confirmTimestamp: tx.confirmTimestamp }
                 : {})
-        }))
+        };
+    }
+    listOnchainTransactions() {
+        return Object.values(this.wallet.transactions)
+            .map((tx) => this.toOnchainTxInfo(tx))
             .sort((a, b) => b.timestamp - a.timestamp);
     }
     listUtxos() {
@@ -636,9 +1104,43 @@ class BeignetNode extends events_1.EventEmitter {
             vout: utxo.tx_pos,
             address: utxo.address,
             valueSats: utxo.value,
-            height: utxo.height
+            height: utxo.height,
+            frozen: this.wallet.isUtxoFrozen(utxo.tx_hash, utxo.tx_pos)
         }));
     }
+    async freezeUtxo(txid, index) {
+        this._validateTxid(txid);
+        const res = await this.wallet.freezeUtxo({ txid, index });
+        if (res.isErr()) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
+        }
+        return { frozen: `${txid}:${index}` };
+    }
+    async unfreezeUtxo(txid, index) {
+        this._validateTxid(txid);
+        const res = await this.wallet.unfreezeUtxo({ txid, index });
+        if (res.isErr()) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
+        }
+        return { unfrozen: `${txid}:${index}` };
+    }
+    async setAddressLabel(address, label) {
+        const res = await this.wallet.setAddressLabel(address, label);
+        if (res.isErr()) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
+        }
+        return { address, label };
+    }
+    listAddressLabels() {
+        return this.wallet.listAddressLabels();
+    }
+    exportDescriptors() {
+        const res = this.wallet.exportDescriptors();
+        if (res.isErr()) {
+            throw new errors_1.BeignetError('DESCRIPTOR_EXPORT_FAILED', res.error.message);
+        }
+        return res.value;
+    }
     async getFeeEstimates() {
         try {
             return await this.wallet.getFeeEstimates();
@@ -654,10 +1156,13 @@ class BeignetNode extends events_1.EventEmitter {
         return this.wallet;
     }
     async connectPeer(pubkey, host, port) {
+        const target = host !== undefined && port !== undefined
+            ? `${host}:${port}`
+            : 'resolved address (gossip graph / DNS bootstrap)';
         let timer;
         const connectPromise = this.node.connectPeer(pubkey, host, port);
         const timeoutPromise = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new errors_1.BeignetError('CONNECT_TIMEOUT', `connectPeer timed out after ${this._connectTimeoutMs}ms (is ${host}:${port} the peer's P2P address?)`)), this._connectTimeoutMs);
+            timer = setTimeout(() => reject(new errors_1.BeignetError('CONNECT_TIMEOUT', `connectPeer timed out after ${this._connectTimeoutMs}ms (is ${target} the peer's P2P address?)`)), this._connectTimeoutMs);
         });
         try {
             await Promise.race([connectPromise, timeoutPromise]);
@@ -665,13 +1170,19 @@ class BeignetNode extends events_1.EventEmitter {
         catch (err) {
             if (err instanceof errors_1.BeignetError)
                 throw err;
-            throw new errors_1.BeignetError('CONNECT_FAILED', `Failed to connect to ${pubkey.slice(0, 16)}…@${host}:${port}: ${err.message}`);
+            throw new errors_1.BeignetError('CONNECT_FAILED', `Failed to connect to ${pubkey.slice(0, 16)}…@${target}: ${err.message}`);
         }
         finally {
             if (timer)
                 clearTimeout(timer);
         }
-        return { pubkey, host, port, state: 'connected' };
+        const connected = this.node.listPeers().find((p) => p.pubkey === pubkey);
+        return {
+            pubkey,
+            host: host ?? connected?.host ?? '',
+            port: port ?? connected?.port ?? 0,
+            state: 'connected'
+        };
     }
     disconnectPeer(pubkey) {
         this.node.disconnectPeer(pubkey);
@@ -701,6 +1212,8 @@ class BeignetNode extends events_1.EventEmitter {
                 });
             }
         }
+        if (synced.length > 0)
+            this._lastGraphSyncAt = Date.now();
         return synced;
     }
     async syncRapidGossip() {
@@ -712,6 +1225,7 @@ class BeignetNode extends events_1.EventEmitter {
         this.log('info', 'Rapid gossip sync: downloading snapshot', { url });
         const data = await (0, rapid_sync_1.fetchRapidGossipSnapshot)(url);
         const result = this.node.loadRapidGossipSnapshot(data);
+        this._lastGraphSyncAt = Date.now();
         this.log('info', 'Rapid gossip sync complete', {
             channelsAdded: result.channelsAdded,
             updatesApplied: result.updatesApplied,
@@ -733,6 +1247,7 @@ class BeignetNode extends events_1.EventEmitter {
         const state = channel.getFullState();
         const balances = channel.getBalances();
         const channelId = state.channelId || state.temporaryChannelId;
+        this.refreshStaticChannelBackup();
         return {
             channelId: channelId.toString('hex'),
             peerPubkey: pubkey,
@@ -740,7 +1255,7 @@ class BeignetNode extends events_1.EventEmitter {
             localBalanceSats: Number(balances.localMsat / 1000n),
             remoteBalanceSats: Number(balances.remoteMsat / 1000n),
             capacitySats: amountSats,
-            isAnchor: (0, types_2.isAnchorChannel)(state.channelType)
+            isAnchor: (0, types_3.isAnchorChannel)(state.channelType)
         };
     }
     async openChannelAndWait(pubkey, amountSats, opts) {
@@ -882,7 +1397,7 @@ class BeignetNode extends events_1.EventEmitter {
             localBalanceSats: Number(ch.localBalanceMsat / 1000n),
             remoteBalanceSats: Number(ch.remoteBalanceMsat / 1000n),
             capacitySats: Number(ch.fundingSatoshis),
-            isAnchor: (0, types_2.isAnchorChannel)(ch.channelType ?? null)
+            isAnchor: (0, types_3.isAnchorChannel)(ch.channelType ?? null)
         };
         if (ch.fundingTxid)
             info.fundingTxid = ch.fundingTxid;
@@ -894,6 +1409,16 @@ class BeignetNode extends events_1.EventEmitter {
             info.htlcCount = ch.htlcCount;
         if (ch.isPrivate !== undefined)
             info.isPrivate = ch.isPrivate;
+        if (ch.feeBaseMsat !== undefined)
+            info.feeBaseMsat = ch.feeBaseMsat;
+        if (ch.feeProportionalMillionths !== undefined)
+            info.feeProportionalMillionths = ch.feeProportionalMillionths;
+        if (ch.cltvExpiryDelta !== undefined)
+            info.cltvExpiryDelta = ch.cltvExpiryDelta;
+        if (ch.htlcMinimumMsat !== undefined)
+            info.htlcMinimumMsat = ch.htlcMinimumMsat.toString();
+        if (ch.htlcMaximumMsat !== undefined)
+            info.htlcMaximumMsat = ch.htlcMaximumMsat.toString();
         return info;
     }
     createInvoice(amountSats, description, expirySecs, descriptionHash) {
@@ -916,6 +1441,76 @@ class BeignetNode extends events_1.EventEmitter {
             info.expiry = expirySecs;
         return info;
     }
+    createHoldInvoice(opts) {
+        if (!/^[0-9a-fA-F]{64}$/.test(opts.paymentHash)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'paymentHash must be 32 bytes hex (64 hex chars)');
+        }
+        const amountMsat = opts.amountMsat ??
+            (opts.amountSats !== undefined && opts.amountSats !== 0
+                ? BigInt(opts.amountSats) * 1000n
+                : undefined);
+        const result = this.node.createInvoice({
+            amountMsat,
+            description: opts.description || '',
+            expiry: opts.expiry,
+            hold: true,
+            paymentHash: Buffer.from(opts.paymentHash, 'hex')
+        });
+        const info = {
+            bolt11: result.bolt11,
+            paymentHash: result.paymentHash.toString('hex'),
+            paymentSecret: result.paymentSecret.toString('hex')
+        };
+        if (amountMsat !== undefined)
+            info.amountSats = Number(amountMsat / 1000n);
+        if (opts.expiry !== undefined)
+            info.expiry = opts.expiry;
+        return info;
+    }
+    settleHoldInvoice(preimage) {
+        if (!/^[0-9a-fA-F]{64}$/.test(preimage)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'preimage must be 32 bytes hex (64 hex chars)');
+        }
+        const preimageBuf = Buffer.from(preimage, 'hex');
+        const paymentHash = crypto
+            .createHash('sha256')
+            .update(preimageBuf)
+            .digest();
+        const settled = this.node.settleHeldHtlc(paymentHash, preimageBuf);
+        if (!settled) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_FOUND, 'No parked HTLCs for this preimage (invoice unknown, not yet paid, or already resolved)');
+        }
+        return { paymentHash: paymentHash.toString('hex') };
+    }
+    cancelHoldInvoice(paymentHash) {
+        if (!/^[0-9a-fA-F]{64}$/.test(paymentHash)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'paymentHash must be 32 bytes hex (64 hex chars)');
+        }
+        const result = this.node.cancelHoldInvoice(Buffer.from(paymentHash, 'hex'));
+        if (!result) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_FOUND, 'No open hold invoice for this payment hash');
+        }
+        return { paymentHash, htlcsFailed: result.htlcsFailed };
+    }
+    listHoldInvoices() {
+        return this.node.listHoldInvoices().map((inv) => {
+            const info = {
+                paymentHash: inv.paymentHash,
+                bolt11: inv.bolt11,
+                state: inv.state,
+                heldAmountMsat: inv.heldAmountMsat.toString(),
+                htlcCount: inv.htlcCount,
+                expiry: inv.expiry,
+                createdAt: inv.createdAt
+            };
+            if (inv.amountMsat !== undefined) {
+                info.amountSats = Number(inv.amountMsat / 1000n);
+            }
+            if (inv.description)
+                info.description = inv.description;
+            return info;
+        });
+    }
     decodeInvoice(bolt11) {
         const inv = (0, decode_1.decode)(bolt11);
         const result = {
@@ -967,6 +1562,8 @@ class BeignetNode extends events_1.EventEmitter {
             tomorrow.setUTCHours(24, 0, 0, 0);
             this._dailySpendResetTime = tomorrow.getTime();
             this._dailySpentSats = 0;
+            this._dailySpentLightningSats = 0;
+            this._dailySpentOnchainSats = 0;
         }
     }
     _checkSpendLimit(amountSats) {
@@ -986,10 +1583,26 @@ class BeignetNode extends events_1.EventEmitter {
             throw new errors_1.BeignetError('SPENDING_LIMIT_EXCEEDED', `Payment amount ${amountSats} sats exceeds per-payment limit of ${this._maxPaymentSats} sats`);
         }
     }
-    _recordSpend(amountSats) {
+    _recordSpend(amountSats, source = 'lightning') {
         if (this._dailySpendLimitSats === undefined)
             return;
         this._dailySpentSats += amountSats;
+        if (source === 'onchain') {
+            this._dailySpentOnchainSats += amountSats;
+        }
+        else {
+            this._dailySpentLightningSats += amountSats;
+        }
+    }
+    _builtOnchainTotalSats(amountSats) {
+        const feeSats = this.wallet.transaction?.data?.fee;
+        if (!Number.isFinite(feeSats) || feeSats < 0) {
+            if (this._dailySpendLimitSats !== undefined) {
+                throw new errors_1.BeignetError('SPENDING_LIMIT_EXCEEDED', 'Unable to determine the transaction fee for the daily spend limit check; refusing to send');
+            }
+            return amountSats;
+        }
+        return amountSats + feeSats;
     }
     getDailySpendInfo() {
         this._resetDailySpendIfNeeded();
@@ -998,7 +1611,10 @@ class BeignetNode extends events_1.EventEmitter {
             limitSats: limit,
             spentSats: this._dailySpentSats,
             remainingSats: limit !== null ? Math.max(0, limit - this._dailySpentSats) : Infinity,
-            resetsAt: this._dailySpendResetTime
+            resetsAt: this._dailySpendResetTime,
+            totalSats: this._dailySpentSats,
+            lightningSats: this._dailySpentLightningSats,
+            onchainSats: this._dailySpentOnchainSats
         };
     }
     setDraining(enabled) {
@@ -1543,6 +2159,36 @@ class BeignetNode extends events_1.EventEmitter {
             return null;
         return this.toPaymentInfo(p);
     }
+    listForwards(filter) {
+        return this.node.listForwards(filter).map((f) => ({
+            id: f.id,
+            settledAt: f.settledAt,
+            inChannelId: f.inChannelId,
+            outChannelId: f.outChannelId,
+            inScid: f.inScid,
+            outScid: f.outScid,
+            amountInMsat: f.amountInMsat.toString(),
+            amountOutMsat: f.amountOutMsat.toString(),
+            feeMsat: f.feeMsat.toString()
+        }));
+    }
+    getForwardingSummary(since) {
+        const summary = this.node.getForwardingSummary(since !== undefined ? { since } : undefined);
+        return {
+            count: summary.count,
+            volumeOutMsat: summary.volumeOutMsat.toString(),
+            feesEarnedMsat: summary.feesEarnedMsat.toString()
+        };
+    }
+    listWatchtowers() {
+        return this.node.getWatchtowers();
+    }
+    addWatchtower(uri) {
+        this.node.addWatchtower(uri);
+    }
+    removeWatchtower(uri) {
+        this.node.removeWatchtower(uri);
+    }
     getPaymentProof(paymentHash) {
         const proof = this.node.getPaymentProof(Buffer.from(paymentHash, 'hex'));
         if (!proof)
@@ -1579,6 +2225,41 @@ class BeignetNode extends events_1.EventEmitter {
     updateChannelFee(channelId, feeratePerKw) {
         return this.node.updateChannelFee(Buffer.from(channelId, 'hex'), feeratePerKw);
     }
+    updateChannelPolicy(channelId, policy) {
+        const update = {};
+        if (policy.feeBaseMsat !== undefined)
+            update.feeBaseMsat = policy.feeBaseMsat;
+        if (policy.feeProportionalMillionths !== undefined)
+            update.feeProportionalMillionths = policy.feeProportionalMillionths;
+        if (policy.cltvExpiryDelta !== undefined)
+            update.cltvExpiryDelta = policy.cltvExpiryDelta;
+        if (policy.htlcMinimumMsat !== undefined)
+            update.htlcMinimumMsat = BigInt(policy.htlcMinimumMsat);
+        if (policy.htlcMaximumMsat !== undefined)
+            update.htlcMaximumMsat = BigInt(policy.htlcMaximumMsat);
+        const targets = channelId === 'all'
+            ? this.node.listChannels().map((ch) => ch.channelId.toString('hex'))
+            : [channelId];
+        this.node.setChannelPolicy(channelId === 'all' ? 'all' : Buffer.from(channelId, 'hex'), update);
+        const policies = targets
+            .map((id) => this.getChannelPolicy(id))
+            .filter((p) => p !== null);
+        return { updated: policies.length, policies };
+    }
+    getChannelPolicy(channelId) {
+        const policy = this.node.getChannelPolicy(Buffer.from(channelId, 'hex'));
+        if (!policy)
+            return null;
+        return {
+            channelId,
+            feeBaseMsat: policy.feeBaseMsat,
+            feeProportionalMillionths: policy.feeProportionalMillionths,
+            cltvExpiryDelta: policy.cltvExpiryDelta,
+            htlcMinimumMsat: policy.htlcMinimumMsat.toString(),
+            htlcMaximumMsat: policy.htlcMaximumMsat.toString(),
+            source: policy.source
+        };
+    }
     cancelPayment(paymentHash) {
         this.node.failPayment(Buffer.from(paymentHash, 'hex'));
         return { ok: true };
@@ -1662,6 +2343,7 @@ class BeignetNode extends events_1.EventEmitter {
         const state = channel.getFullState();
         const balances = channel.getBalances();
         const channelId = state.channelId || state.temporaryChannelId;
+        this.refreshStaticChannelBackup();
         return {
             channelId: channelId.toString('hex'),
             peerPubkey,
@@ -1669,7 +2351,7 @@ class BeignetNode extends events_1.EventEmitter {
             localBalanceSats: Number(balances.localMsat / 1000n),
             remoteBalanceSats: Number(balances.remoteMsat / 1000n),
             capacitySats: amountSats,
-            isAnchor: (0, types_2.isAnchorChannel)(state.channelType)
+            isAnchor: (0, types_3.isAnchorChannel)(state.channelType)
         };
     }
     openChannelV2(peerPubkey, params) {
@@ -1682,6 +2364,7 @@ class BeignetNode extends events_1.EventEmitter {
         const state = channel.getFullState();
         const balances = channel.getBalances();
         const channelId = state.channelId || state.temporaryChannelId;
+        this.refreshStaticChannelBackup();
         return {
             channelId: channelId.toString('hex'),
             peerPubkey,
@@ -1689,16 +2372,20 @@ class BeignetNode extends events_1.EventEmitter {
             localBalanceSats: Number(balances.localMsat / 1000n),
             remoteBalanceSats: Number(balances.remoteMsat / 1000n),
             capacitySats: params.amountSats,
-            isAnchor: (0, types_2.isAnchorChannel)(state.channelType)
+            isAnchor: (0, types_3.isAnchorChannel)(state.channelType)
         };
     }
     spliceIn(channelId, amountSats, feeratePerkw) {
         const idBuf = Buffer.from(channelId, 'hex');
-        return this.node.spliceIn(idBuf, BigInt(amountSats), feeratePerkw);
+        const result = this.node.spliceIn(idBuf, BigInt(amountSats), feeratePerkw);
+        this.refreshStaticChannelBackup();
+        return result;
     }
     spliceOut(channelId, amountSats, feeratePerkw) {
         const idBuf = Buffer.from(channelId, 'hex');
-        return this.node.spliceOut(idBuf, BigInt(amountSats), feeratePerkw);
+        const result = this.node.spliceOut(idBuf, BigInt(amountSats), feeratePerkw);
+        this.refreshStaticChannelBackup();
+        return result;
     }
     decodeOfferString(offerStr) {
         const offer = (0, decode_2.decodeOffer)(offerStr);
@@ -1915,7 +2602,7 @@ class BeignetNode extends events_1.EventEmitter {
                 ? 'Networking and auto-reconnect enabled'
                 : 'Networking disabled — node cannot reconnect to peers'
         });
-        const hasAnchor = channels.some((ch) => ch.channelType != null && (0, types_2.isAnchorChannel)(ch.channelType));
+        const hasAnchor = channels.some((ch) => ch.channelType != null && (0, types_3.isAnchorChannel)(ch.channelType));
         checks.push({
             name: 'ANCHOR_CHANNELS_PREFERRED',
             status: hasAnchor || channels.length === 0 ? 'PASS' : 'WARN',
@@ -2032,6 +2719,70 @@ class BeignetNode extends events_1.EventEmitter {
             recommendations: snapshot.recommendations
         };
     }
+    getAdvisorRecommendations() {
+        const plan = this.node
+            .planRebalanceRecommendations()
+            .map((p) => ({
+            fromChannelId: p.fromChannelId,
+            toChannelId: p.toChannelId,
+            amountSats: Number(p.amountSats),
+            reason: p.reason
+        }));
+        return { ...this.getLiquiditySnapshot(), rebalancePlan: plan };
+    }
+    async rebalanceChannel(fromChannelId, toChannelId, amountSats, maxFeeSats) {
+        if (!/^[0-9a-fA-F]{64}$/.test(fromChannelId))
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'fromChannelId must be 64 hex chars');
+        if (!/^[0-9a-fA-F]{64}$/.test(toChannelId))
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'toChannelId must be 64 hex chars');
+        if (!Number.isInteger(amountSats) || amountSats <= 0)
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'amountSats must be a positive integer');
+        if (!Number.isInteger(maxFeeSats) || maxFeeSats < 0)
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'maxFeeSats must be a non-negative integer');
+        const result = await this.node.rebalanceChannel({
+            fromChannelId: Buffer.from(fromChannelId, 'hex'),
+            toChannelId: Buffer.from(toChannelId, 'hex'),
+            amountSats: BigInt(amountSats),
+            maxFeeSats: BigInt(maxFeeSats)
+        });
+        this.log('info', 'Rebalance completed', {
+            fromChannelId,
+            toChannelId,
+            amountSats,
+            feeMsat: result.feeMsat.toString()
+        });
+        return {
+            paymentHash: result.paymentHash.toString('hex'),
+            amountSats,
+            feeMsat: result.feeMsat.toString(),
+            feeSats: Number(result.feeMsat / 1000n),
+            hops: result.hops
+        };
+    }
+    async executeRebalances(budgetSatsPerDay) {
+        if (budgetSatsPerDay !== undefined &&
+            (!Number.isInteger(budgetSatsPerDay) || budgetSatsPerDay < 0)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'budgetSatsPerDay must be a non-negative integer');
+        }
+        const summary = await this.node.executeRebalanceRecommendations({
+            budgetSatsPerDay
+        });
+        return {
+            attempts: summary.attempts.map((a) => ({
+                fromChannelId: a.fromChannelId,
+                toChannelId: a.toChannelId,
+                amountSats: Number(a.amountSats),
+                status: a.status,
+                feeMsat: a.feeMsat?.toString(),
+                error: a.error
+            })),
+            succeeded: summary.succeeded,
+            failed: summary.failed,
+            skippedBudget: summary.skippedBudget,
+            feeSpentMsat: summary.feeSpentMsat.toString(),
+            budgetRemainingMsat: summary.budgetRemainingMsat.toString()
+        };
+    }
     getFeeSnapshot() {
         return this.node.getFeeSnapshot();
     }
@@ -2047,10 +2798,160 @@ class BeignetNode extends events_1.EventEmitter {
     probeRoute(destination, amountSats) {
         return this.node.probeRoute(destination, amountSats);
     }
+    getGraphInfo() {
+        const graph = this.node.getGraph();
+        const info = {
+            nodeCount: graph.getNodeCount(),
+            channelCount: graph.getChannelCount()
+        };
+        if (this._lastGraphSyncAt !== undefined) {
+            info.lastSyncAt = this._lastGraphSyncAt;
+        }
+        return info;
+    }
+    getGraphNode(pubkey) {
+        if (!/^[0-9a-fA-F]{66}$/.test(pubkey)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'pubkey must be a 33-byte hex string');
+        }
+        const graph = this.node.getGraph();
+        const node = graph.getNode(Buffer.from(pubkey, 'hex'));
+        if (!node)
+            return null;
+        const info = {
+            pubkey: node.nodeId.toString('hex'),
+            channelCount: node.channels.size,
+            channels: graph
+                .getNodeChannels(node.nodeId)
+                .map((ch) => formatScid(ch.shortChannelId))
+        };
+        const ann = node.announcement;
+        if (ann) {
+            const alias = ann.alias
+                .subarray(0, ann.alias.indexOf(0) === -1 ? 32 : ann.alias.indexOf(0))
+                .toString('utf8');
+            if (alias.length > 0)
+                info.alias = alias;
+            info.color = ann.rgbColor.toString('hex');
+            info.addresses = ann.addresses.map((a) => ({
+                type: a.type,
+                host: a.host,
+                port: a.port
+            }));
+            info.featuresHex = ann.features.toString('hex');
+            info.lastUpdate = ann.timestamp;
+        }
+        return info;
+    }
+    getGraphChannel(scid) {
+        const scidBuf = parseScid(scid);
+        const channel = this.node.getGraph().getChannel(scidBuf);
+        if (!channel)
+            return null;
+        return this.toGraphChannelInfo(channel);
+    }
+    describeGraph(limit, offset) {
+        const cappedLimit = Math.min(Math.max(1, Math.floor(limit ?? GRAPH_DESCRIBE_MAX_LIMIT)), GRAPH_DESCRIBE_MAX_LIMIT);
+        const safeOffset = Math.max(0, Math.floor(offset ?? 0));
+        const all = this.node.getGraph().getAllChannels();
+        return {
+            totalChannels: all.length,
+            limit: cappedLimit,
+            offset: safeOffset,
+            channels: all
+                .slice(safeOffset, safeOffset + cappedLimit)
+                .map((ch) => this.toGraphChannelInfo(ch))
+        };
+    }
+    toGraphChannelInfo(channel) {
+        const info = {
+            shortChannelId: formatScid(channel.shortChannelId),
+            node1Pubkey: channel.nodeId1.toString('hex'),
+            node2Pubkey: channel.nodeId2.toString('hex')
+        };
+        const max1 = channel.update1?.htlcMaximumMsat;
+        const max2 = channel.update2?.htlcMaximumMsat;
+        const best = (max1 ?? 0n) > (max2 ?? 0n) ? max1 : max2;
+        if (best !== undefined)
+            info.capacitySats = Number(best / 1000n);
+        if (channel.update1) {
+            info.node1Policy = this.toGraphChannelPolicy(channel.update1);
+        }
+        if (channel.update2) {
+            info.node2Policy = this.toGraphChannelPolicy(channel.update2);
+        }
+        return info;
+    }
+    toGraphChannelPolicy(update) {
+        const policy = {
+            feeBaseMsat: update.feeBaseMsat,
+            feeProportionalMillionths: update.feeProportionalMillionths,
+            cltvExpiryDelta: update.cltvExpiryDelta,
+            htlcMinimumMsat: update.htlcMinimumMsat.toString(),
+            disabled: (update.channelFlags & types_1.CHANNEL_FLAG_DISABLED) !== 0,
+            lastUpdate: update.timestamp
+        };
+        if (update.htlcMaximumMsat !== undefined) {
+            policy.htlcMaximumMsat = update.htlcMaximumMsat.toString();
+        }
+        return policy;
+    }
+    queryRoute(destination, amountSats, maxFeeSats) {
+        if (!/^[0-9a-fA-F]{66}$/.test(destination)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'destination must be a 33-byte hex string');
+        }
+        if (!Number.isInteger(amountSats) || amountSats <= 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'amountSats must be a positive integer');
+        }
+        const amountMsat = BigInt(amountSats) * 1000n;
+        const route = this.node.queryRoute(Buffer.from(destination, 'hex'), amountMsat, types_2.DEFAULT_MIN_FINAL_CLTV_EXPIRY);
+        if (!route) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NO_ROUTE, 'No route found to destination');
+        }
+        if (maxFeeSats !== undefined &&
+            route.totalFeeMsat > BigInt(maxFeeSats) * 1000n) {
+            throw new errors_1.BeignetError('FEE_EXCEEDS_MAX', `Route fee ${route.totalFeeMsat} msat exceeds maximum ${maxFeeSats} sats`);
+        }
+        return {
+            destination,
+            amountSats,
+            hops: routeHopsToJson(route),
+            totalAmountMsat: route.totalAmountMsat.toString(),
+            totalFeeMsat: route.totalFeeMsat.toString(),
+            totalCltvDelta: route.totalCltvDelta,
+            finalCltvExpiry: types_2.DEFAULT_MIN_FINAL_CLTV_EXPIRY
+        };
+    }
+    sendToRoute(paymentHash, route, paymentSecret) {
+        if (!/^[0-9a-fA-F]{64}$/.test(paymentHash)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'paymentHash must be a 32-byte hex string');
+        }
+        if (!route || !Array.isArray(route.hops) || route.hops.length === 0) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'route.hops must be a non-empty array');
+        }
+        if (paymentSecret !== undefined &&
+            !/^[0-9a-fA-F]{64}$/.test(paymentSecret)) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'paymentSecret must be a 32-byte hex string');
+        }
+        this._checkDraining();
+        const hops = jsonToRouteHops(route.hops);
+        const finalHop = hops[hops.length - 1];
+        try {
+            const payment = this.node.sendPaymentToRoute({ hops }, Buffer.from(paymentHash, 'hex'), finalHop.outgoingCltvValue, paymentSecret ? Buffer.from(paymentSecret, 'hex') : undefined, finalHop.amountToForwardMsat);
+            return this.toPaymentInfo(payment);
+        }
+        catch (err) {
+            if (err instanceof errors_1.BeignetError)
+                throw err;
+            const code = err !== null && typeof err === 'object' && 'code' in err
+                ? String(err.code)
+                : 'PAYMENT_FAILED';
+            throw new errors_1.BeignetError(code, err instanceof Error ? err.message : String(err));
+        }
+    }
     getReadyChannels() {
         return this.node
             .listChannels()
-            .filter((ch) => ch.state === types_2.ChannelState.NORMAL)
+            .filter((ch) => ch.state === types_3.ChannelState.NORMAL)
             .map((ch) => this.toChannelInfo(ch));
     }
     canSend(amountSats) {
@@ -2059,7 +2960,7 @@ class BeignetNode extends events_1.EventEmitter {
         let bestAvailableMsat = 0n;
         let totalAvailableMsat = 0n;
         for (const ch of this.node.listChannels()) {
-            if (ch.state !== types_2.ChannelState.NORMAL)
+            if (ch.state !== types_3.ChannelState.NORMAL)
                 continue;
             const reserveMsat = ch.localReserveMsat ?? 0n;
             const available = ch.localBalanceMsat > reserveMsat
@@ -2083,7 +2984,7 @@ class BeignetNode extends events_1.EventEmitter {
         let bestAvailableMsat = 0n;
         let totalAvailableMsat = 0n;
         for (const ch of this.node.listChannels()) {
-            if (ch.state !== types_2.ChannelState.NORMAL)
+            if (ch.state !== types_3.ChannelState.NORMAL)
                 continue;
             const reserveMsat = ch.remoteReserveMsat ?? 0n;
             const available = ch.remoteBalanceMsat > reserveMsat
@@ -2277,6 +3178,86 @@ class BeignetNode extends events_1.EventEmitter {
     triggerBackup() {
         this.performScheduledBackup();
     }
+    exportStaticChannelBackup() {
+        const data = this.node.buildStaticChannelBackupData();
+        const backup = {
+            version: 1,
+            network: data.network,
+            createdAt: Date.now(),
+            channels: data.channels
+        };
+        const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+        const encoded = (0, scb_1.encodeScb)(backup, seed);
+        const scbPath = path.join(this.dataDir, 'channels.scb');
+        const tmpPath = `${scbPath}.tmp`;
+        fs.writeFileSync(tmpPath, encoded);
+        fs.renameSync(tmpPath, scbPath);
+        return { encoded, channelCount: data.channels.length, path: scbPath };
+    }
+    async restoreFromScb(encoded) {
+        const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+        const backup = (0, scb_1.decodeScb)(encoded.trim(), seed);
+        const expectedNetwork = this.toLnNetwork(this.networkName);
+        if (backup.network !== expectedNetwork) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', `SCB network "${backup.network}" does not match this node's network "${expectedNetwork}"`);
+        }
+        const { recovering, skipped } = await this.node.recoverFromStaticChannelBackup(backup.channels);
+        this.log('info', 'SCB restore processed', {
+            channelCount: backup.channels.length,
+            recovering: recovering.length,
+            skipped: skipped.length
+        });
+        return { recovering, skipped, channelCount: backup.channels.length };
+    }
+    refreshStaticChannelBackup() {
+        if (this.destroyed)
+            return;
+        try {
+            const { encoded } = this.exportStaticChannelBackup();
+            if (this.peerStorageEnabled) {
+                const sent = this.node.distributePeerStorage(Buffer.from(encoded, 'utf8'));
+                if (sent > 0) {
+                    this.log('debug', 'Pushed SCB to peer storage', { peers: sent });
+                }
+            }
+        }
+        catch (err) {
+            this.log('warn', 'Static channel backup refresh failed', {
+                error: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    handleRetrievedPeerStorage(peerPubkey, blob) {
+        let backup;
+        const encoded = blob.toString('utf8');
+        try {
+            const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+            backup = (0, scb_1.decodeScb)(encoded, seed);
+        }
+        catch {
+            this.log('debug', 'Ignoring peer storage blob that is not our SCB', {
+                fromPeer: peerPubkey
+            });
+            return;
+        }
+        if (this._peerRetrievedScb &&
+            this._peerRetrievedScb.createdAt >= backup.createdAt) {
+            return;
+        }
+        this._peerRetrievedScb = {
+            encoded,
+            createdAt: backup.createdAt,
+            fromPeer: peerPubkey
+        };
+        this.log('info', 'Recovered SCB from peer storage', {
+            fromPeer: peerPubkey,
+            createdAt: backup.createdAt,
+            channelCount: backup.channels.length
+        });
+    }
+    getPeerRetrievedBackup() {
+        return this._peerRetrievedScb;
+    }
     getNodeUri(externalHost) {
         if (!this._listenPort)
             return null;
@@ -2366,6 +3347,8 @@ class BeignetNode extends events_1.EventEmitter {
                 return wallet_2.EAvailableNetworks.testnet;
             case 'regtest':
                 return wallet_2.EAvailableNetworks.regtest;
+            case 'signet':
+                return wallet_2.EAvailableNetworks.signet;
             default:
                 return wallet_2.EAvailableNetworks.bitcoin;
         }
@@ -2373,13 +3356,15 @@ class BeignetNode extends events_1.EventEmitter {
     toLnNetwork(network) {
         switch (network) {
             case 'mainnet':
-                return types_1.Network.MAINNET;
+                return types_2.Network.MAINNET;
             case 'testnet':
-                return types_1.Network.TESTNET;
+                return types_2.Network.TESTNET;
             case 'regtest':
-                return types_1.Network.REGTEST;
+                return types_2.Network.REGTEST;
+            case 'signet':
+                return types_2.Network.SIGNET;
             default:
-                return types_1.Network.MAINNET;
+                return types_2.Network.MAINNET;
         }
     }
     toCoinType(network) {
@@ -2390,22 +3375,14 @@ class BeignetNode extends events_1.EventEmitter {
                 return wallet_keys_1.LnCoinType.TESTNET;
             case 'regtest':
                 return wallet_keys_1.LnCoinType.REGTEST;
+            case 'signet':
+                return wallet_keys_1.LnCoinType.SIGNET;
             default:
                 return wallet_keys_1.LnCoinType.BITCOIN;
         }
     }
     getBitcoinNetwork() {
-        const bitcoin = require('bitcoinjs-lib');
-        switch (this.networkName) {
-            case 'mainnet':
-                return bitcoin.networks.bitcoin;
-            case 'testnet':
-                return bitcoin.networks.testnet;
-            case 'regtest':
-                return bitcoin.networks.regtest;
-            default:
-                return bitcoin.networks.bitcoin;
-        }
+        return (0, helpers_1.getBitcoinJsNetwork)(this.toBeignetNetwork(this.networkName));
     }
 }
 exports.BeignetNode = BeignetNode;