beignet 0.2.0 → 0.3.0

package/dist/lightning/node/lightning-node.js

@@ -30,6 +30,7 @@ exports.LightningNode = void 0;
 const events_1 = require("events");
 const crypto_1 = __importDefault(require("crypto"));
 const ecdh_1 = require("../crypto/ecdh");
+const message_signing_1 = require("../crypto/message-signing");
 const blinded_path_1 = require("../onion/blinded-path");
 const channel_manager_1 = require("../channel/channel-manager");
 const channel_1 = require("../channel/channel");
@@ -40,6 +41,7 @@ const network_graph_1 = require("../gossip/network-graph");
 const pathfinding_1 = require("../gossip/pathfinding");
 const rapid_sync_1 = require("../gossip/rapid-sync");
 const mission_control_1 = require("../gossip/mission-control");
+const types_2 = require("../gossip/types");
 const messages_1 = require("../gossip/messages");
 const gossip_queries_1 = require("../gossip/gossip-queries");
 const gossip_sync_1 = require("../gossip/gossip-sync");
@@ -48,20 +50,22 @@ const construct_1 = require("../onion/construct");
 const process_1 = require("../onion/process");
 const sphinx_crypto_1 = require("../onion/sphinx-crypto");
 const failures_1 = require("../onion/failures");
-const types_2 = require("../onion/types");
+const types_3 = require("../onion/types");
 const encode_1 = require("../invoice/encode");
 const decode_1 = require("../invoice/decode");
-const types_3 = require("../invoice/types");
-const types_4 = require("../message/types");
-const types_5 = require("./types");
+const types_4 = require("../invoice/types");
+const types_5 = require("../message/types");
+const peer_storage_1 = require("../message/peer-storage");
+const types_6 = require("./types");
 const validation_2 = require("../validation");
 const bitcoin = __importStar(require("bitcoinjs-lib"));
 const ecc = __importStar(require("@bitcoinerlab/secp256k1"));
 const flags_1 = require("../features/flags");
 const chain_watcher_1 = require("../chain/chain-watcher");
 const sweep_1 = require("../chain/sweep");
-const types_6 = require("../chain/types");
+const types_7 = require("../chain/types");
 const chain_monitor_1 = require("../chain/chain-monitor");
+const watchtower_1 = require("../watchtower");
 const wallet_keys_1 = require("../keys/wallet-keys");
 const bip32Lib = __importStar(require("bip32"));
 const bip39 = __importStar(require("bip39"));
@@ -69,7 +73,8 @@ const shachain_1 = require("../keys/shachain");
 const derivation_1 = require("../keys/derivation");
 const funding_1 = require("../script/funding");
 const funding_taproot_1 = require("../script/funding-taproot");
-const types_7 = require("../channel/types");
+const types_8 = require("../channel/types");
+const channel_state_1 = require("../channel/channel-state");
 const commitment_builder_1 = require("../channel/commitment-builder");
 const signer_1 = require("../keys/signer");
 const bootstrap_1 = require("../bootstrap");
@@ -80,6 +85,8 @@ const rate_limiter_1 = require("./rate-limiter");
 const liquidity_advisor_1 = require("../advisor/liquidity-advisor");
 const fee_advisor_1 = require("../advisor/fee-advisor");
 const channel_suggestions_1 = require("../advisor/channel-suggestions");
+const rebalance_planner_1 = require("../advisor/rebalance-planner");
+const fee_tuner_1 = require("../advisor/fee-tuner");
 bitcoin.initEccLib(ecc);
 const GOSSIP_REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000;
 const HELD_HTLC_EXPIRY_MARGIN = 18;
@@ -100,6 +107,7 @@ class LightningNode extends events_1.EventEmitter {
         this.chainWatcher = null;
         this._chainWatcherEventsWired = false;
         this.currentBlockHeight = 0;
+        this.channelPolicies = new Map();
         this.gossipSyncManagers = new Map();
         this._ownChannelGossip = new Map();
         this.pendingMppPayments = new Map();
@@ -131,10 +139,19 @@ class LightningNode extends events_1.EventEmitter {
         this.liquidityAdvisor = new liquidity_advisor_1.LiquidityAdvisor();
         this.feeAdvisor = new fee_advisor_1.FeeAdvisor();
         this.channelSuggestions = new channel_suggestions_1.ChannelSuggestions();
+        this.autoRebalanceTimer = null;
+        this.autoTuneFeesTimer = null;
+        this.rebalanceBudgetDay = null;
+        this.rebalanceRunInFlight = false;
+        this.watchtowerClient = null;
+        this.peerStorageBlobs = new Map();
+        this.peerStorageLastAccepted = new Map();
+        this.ourPeerStorageBlob = null;
+        this.retrievedPeerStorage = new Map();
         this.setMaxListeners(50);
         this.nodePrivkey = config.nodePrivateKey;
         this.nodeId = (0, ecdh_1.getPublicKey)(config.nodePrivateKey).toString('hex');
-        this.network = config.network || types_3.Network.REGTEST;
+        this.network = config.network || types_4.Network.REGTEST;
         this.acceptableChainHashes = config.chainHashes ?? [];
         this.storage = config.storage || null;
         this.resourceConfig = {
@@ -158,6 +175,8 @@ class LightningNode extends events_1.EventEmitter {
         this.revocationBasepointSecret = config.revocationBasepointSecret;
         this.paymentBasepointSecret = config.paymentBasepointSecret;
         this.feeEstimator = config.feeEstimator || null;
+        this.socks5Proxy = config.socks5Proxy ?? null;
+        this.initWatchtowerClient(config.watchtowers ?? []);
         this.missionControl = new mission_control_1.MissionControl();
         this.maxPaymentRetries = config.maxPaymentRetries ?? 3;
         this.maxTotalInFlightHtlcs = config.maxTotalInFlightHtlcs ?? 1000;
@@ -170,6 +189,15 @@ class LightningNode extends events_1.EventEmitter {
             !localFeatures.hasFeature(flags_1.Feature.ANCHOR_ZERO_FEE_HTLC)) {
             localFeatures.setOptional(flags_1.Feature.ANCHOR_ZERO_FEE_HTLC);
         }
+        this.largeChannels = config.largeChannels ?? false;
+        if (this.largeChannels) {
+            localFeatures.setOptional(flags_1.Feature.LARGE_CHANNELS);
+        }
+        this.peerStorageEnabled = config.peerStorageEnabled ?? true;
+        if (!this.peerStorageEnabled) {
+            localFeatures.clearBit(flags_1.Feature.PROVIDE_STORAGE);
+            localFeatures.clearBit(flags_1.Feature.PROVIDE_STORAGE + 1);
+        }
         this.channelManager = new channel_manager_1.ChannelManager({
             localFeatures,
             localConfig: config.channelConfig,
@@ -184,7 +212,8 @@ class LightningNode extends events_1.EventEmitter {
             preferTaproot: config.preferTaproot,
             chainHash: config.chainHashes?.[0],
             nodePrivateKey: config.nodePrivateKey,
-            channelKeyDeriver: config.channelKeyDeriver
+            channelKeyDeriver: config.channelKeyDeriver,
+            largeChannels: this.largeChannels
         });
         this.channelManager.setFundingProvider(this.fundingProvider);
         this.graph = new network_graph_1.NetworkGraph();
@@ -211,6 +240,7 @@ class LightningNode extends events_1.EventEmitter {
             this.channelManager.attachToPeerManager(this.peerManager);
             this.registerGossipHandlers();
             this.registerOnionMessageHandler();
+            this.registerPeerStorageHandlers();
             this.wirePeerManagerEvents();
         }
         if (config.chainBackend) {
@@ -269,6 +299,35 @@ class LightningNode extends events_1.EventEmitter {
                 this.missionControlTimer.unref();
             }
         }
+        this.autoRebalanceConfig = config.autoRebalance ?? {};
+        this.autoTuneFeesConfig = config.autoTuneFees ?? {};
+        if (this.autoRebalanceConfig.enabled === true) {
+            this.autoRebalanceTimer = setInterval(() => {
+                this.executeRebalanceRecommendations().catch((err) => {
+                    this.emitStructuredLog('payment', 'auto_rebalance_failed', {
+                        error: err instanceof Error ? err.message : String(err)
+                    });
+                });
+            }, this.autoRebalanceConfig.intervalMs ?? 3600000);
+            if (this.autoRebalanceTimer.unref) {
+                this.autoRebalanceTimer.unref();
+            }
+        }
+        if (this.autoTuneFeesConfig.enabled === true) {
+            this.autoTuneFeesTimer = setInterval(() => {
+                try {
+                    this.runFeeTuneOnce();
+                }
+                catch (err) {
+                    this.emitStructuredLog('fee', 'auto_tune_failed', {
+                        error: err instanceof Error ? err.message : String(err)
+                    });
+                }
+            }, this.autoTuneFeesConfig.intervalMs ?? 21600000);
+            if (this.autoTuneFeesTimer.unref) {
+                this.autoTuneFeesTimer.unref();
+            }
+        }
         this.graphPruneTimer = setInterval(() => {
             this.pruneStaleGossipWithStorage();
         }, 3600000);
@@ -332,13 +391,35 @@ class LightningNode extends events_1.EventEmitter {
         for (const { key, secret } of this.storage.loadAllHtlcSharedSecrets()) {
             this.receivedHtlcSharedSecrets.set(key, secret);
         }
+        if (this.storage.loadAllChannelPolicies) {
+            for (const { channelId, policy } of this.storage.loadAllChannelPolicies()) {
+                const override = {};
+                if (policy.feeBaseMsat !== undefined)
+                    override.feeBaseMsat = policy.feeBaseMsat;
+                if (policy.feeProportionalMillionths !== undefined)
+                    override.feeProportionalMillionths = policy.feeProportionalMillionths;
+                if (policy.cltvExpiryDelta !== undefined)
+                    override.cltvExpiryDelta = policy.cltvExpiryDelta;
+                if (policy.htlcMinimumMsat !== undefined)
+                    override.htlcMinimumMsat = BigInt(policy.htlcMinimumMsat);
+                if (policy.htlcMaximumMsat !== undefined)
+                    override.htlcMaximumMsat = BigInt(policy.htlcMaximumMsat);
+                this.channelPolicies.set(channelId, override);
+            }
+        }
         for (const { paymentHashHex, invoice } of this.storage.loadAllInvoices()) {
             if (invoice.createdAt > 10000000000) {
                 invoice.createdAt = Math.floor(invoice.createdAt / 1000);
             }
             this.invoices.set(paymentHashHex, invoice);
             if (invoice.hold) {
-                this.heldInvoiceHashes.add(paymentHashHex);
+                if (invoice.cancelledAt) {
+                    this.preimages.delete(paymentHashHex);
+                    this.paymentSecrets.delete(paymentHashHex);
+                }
+                else {
+                    this.heldInvoiceHashes.add(paymentHashHex);
+                }
             }
         }
         const heldJson = this.storage.loadMetadata('held_htlcs');
@@ -408,10 +489,11 @@ class LightningNode extends events_1.EventEmitter {
             if (this.feeEstimator) {
                 this.feeEstimator
                     .estimateFee(6)
-                    .then((satPerVbyte) => {
+                    .then((rawSatPerVbyte) => {
+                    const satPerVbyte = this.clampEstimatedFeeRate(rawSatPerVbyte);
                     if (satPerVbyte > 0) {
                         this.feeAdvisor.recordSample(satPerVbyte);
-                        const feeratePerKw = Math.max((0, types_6.satPerVbyteToSatPerKw)(satPerVbyte), types_6.MIN_FEERATE_PER_KW);
+                        const feeratePerKw = Math.max((0, types_7.satPerVbyteToSatPerKw)(satPerVbyte), types_7.MIN_FEERATE_PER_KW);
                         for (const { channelId: monitorChannelId } of monitors) {
                             const m = this.channelManager.getMonitor(Buffer.from(monitorChannelId, 'hex'));
                             if (m && typeof m.updateFeeRate === 'function') {
@@ -503,6 +585,9 @@ class LightningNode extends events_1.EventEmitter {
         }
     }
     wireChannelManagerEvents() {
+        this.channelManager.on('watchtower:backup', (channelId, _peerPubkey, perCommitmentSecret, revokedTx) => {
+            this.backupRevokedStateToTowers(channelId, perCommitmentSecret, revokedTx);
+        });
         this.channelManager.on('channel:ready', (channelId) => {
             this.registerChannelAliases(channelId);
             this.persistChannel(channelId);
@@ -514,6 +599,27 @@ class LightningNode extends events_1.EventEmitter {
             this.emitReady();
             this.triggerPendingAnnouncementSigning(channelId);
         });
+        this.channelManager.on('channel:opening', (channelId, fundingTxid) => {
+            this.emit('channel:opening', { channelId, fundingTxid });
+            this.emitStructuredLog('channel', 'opening', {
+                channelId: channelId.toString('hex'),
+                fundingTxid: fundingTxid.toString('hex')
+            });
+        });
+        this.channelManager.on('channel:pending-close', (channelId, initiator) => {
+            this.emit('channel:pending-close', { channelId, initiator });
+            this.emitStructuredLog('channel', 'pending_close', {
+                channelId: channelId.toString('hex'),
+                initiator
+            });
+        });
+        this.channelManager.on('channel:force-closing', (channelId, initiator) => {
+            this.emit('channel:force-closing', { channelId, initiator });
+            this.emitStructuredLog('channel', 'force_closing', {
+                channelId: channelId.toString('hex'),
+                initiator
+            });
+        });
         this.channelManager.on('channel:closed', (channelId) => {
             this.persistChannel(channelId);
             this.emit('channel:closed', { channelId });
@@ -558,9 +664,11 @@ class LightningNode extends events_1.EventEmitter {
         });
         this.channelManager.on('htlc:fulfilled', (channelId, htlcId, preimage) => {
             this.handleHtlcFulfilled(channelId, htlcId, preimage);
+            this.emit('htlc:fulfilled', { channelId, htlcId });
         });
         this.channelManager.on('htlc:failed', (channelId, htlcId, reason) => {
             this.handleHtlcFailed(channelId, htlcId, reason);
+            this.emit('htlc:failed', { channelId, htlcId });
         });
         this.channelManager.on('error', (channelId, message) => {
             const err = {
@@ -594,13 +702,16 @@ class LightningNode extends events_1.EventEmitter {
             this.safeStorage(() => this.storage.saveChainMonitor(channelIdHex, monitor.getFullState()), 'saveChainMonitor');
         });
         this.channelManager.on('announcement:ready', (channelId, channelAnnouncement, channelUpdate) => {
-            let signedChannelUpdate = channelUpdate;
-            try {
-                const sig = (0, validation_1.signChannelUpdate)(channelUpdate, this.nodePrivkey);
-                signedChannelUpdate = Buffer.from(channelUpdate);
-                sig.copy(signedChannelUpdate, 0);
-            }
-            catch {
+            let signedChannelUpdate = this.refreshChannelUpdate(channelUpdate, Math.floor(Date.now() / 1000), channelId);
+            if (!signedChannelUpdate) {
+                signedChannelUpdate = channelUpdate;
+                try {
+                    const sig = (0, validation_1.signChannelUpdate)(channelUpdate, this.nodePrivkey);
+                    signedChannelUpdate = Buffer.from(channelUpdate);
+                    sig.copy(signedChannelUpdate, 0);
+                }
+                catch {
+                }
             }
             try {
                 const annMsg = (0, messages_1.decodeChannelAnnouncementMessage)(channelAnnouncement);
@@ -697,14 +808,14 @@ class LightningNode extends events_1.EventEmitter {
         if (!this.peerManager)
             return;
         const gossipTypes = [
-            types_4.MessageType.CHANNEL_ANNOUNCEMENT,
-            types_4.MessageType.NODE_ANNOUNCEMENT,
-            types_4.MessageType.CHANNEL_UPDATE,
-            types_4.MessageType.QUERY_CHANNEL_RANGE,
-            types_4.MessageType.REPLY_CHANNEL_RANGE,
-            types_4.MessageType.QUERY_SHORT_CHANNEL_IDS,
-            types_4.MessageType.REPLY_SHORT_CHANNEL_IDS_END,
-            types_4.MessageType.GOSSIP_TIMESTAMP_FILTER
+            types_5.MessageType.CHANNEL_ANNOUNCEMENT,
+            types_5.MessageType.NODE_ANNOUNCEMENT,
+            types_5.MessageType.CHANNEL_UPDATE,
+            types_5.MessageType.QUERY_CHANNEL_RANGE,
+            types_5.MessageType.REPLY_CHANNEL_RANGE,
+            types_5.MessageType.QUERY_SHORT_CHANNEL_IDS,
+            types_5.MessageType.REPLY_SHORT_CHANNEL_IDS_END,
+            types_5.MessageType.GOSSIP_TIMESTAMP_FILTER
         ];
         for (const type of gossipTypes) {
             this.peerManager.onMessage(type, (pubkey, msgType, payload) => {
@@ -712,10 +823,149 @@ class LightningNode extends events_1.EventEmitter {
             });
         }
     }
+    registerPeerStorageHandlers() {
+        if (!this.peerManager)
+            return;
+        this.peerManager.onMessage(types_5.MessageType.PEER_STORAGE, (pubkey, _t, payload) => {
+            this.handlePeerStorageMessage(pubkey, payload);
+        });
+        this.peerManager.onMessage(types_5.MessageType.PEER_STORAGE_RETRIEVAL, (pubkey, _t, payload) => {
+            this.handlePeerStorageRetrievalMessage(pubkey, payload);
+        });
+    }
+    handlePeerStorageMessage(pubkey, payload) {
+        if (!this.peerStorageEnabled)
+            return;
+        let blob;
+        try {
+            blob = (0, peer_storage_1.decodePeerStorageMessage)(payload).blob;
+        }
+        catch (err) {
+            this.emitStructuredLog('peer', 'peer_storage_invalid', {
+                pubkey,
+                error: err instanceof Error ? err.message : String(err)
+            });
+            return;
+        }
+        if (!this.peerQualifiesForStorage(pubkey)) {
+            this.emitStructuredLog('peer', 'peer_storage_rejected', {
+                pubkey,
+                reason: 'no channel and not trusted'
+            });
+            return;
+        }
+        const now = Date.now();
+        const last = this.peerStorageLastAccepted.get(pubkey);
+        if (last !== undefined &&
+            now - last < LightningNode.PEER_STORAGE_MIN_INTERVAL_MS) {
+            return;
+        }
+        this.peerStorageLastAccepted.set(pubkey, now);
+        this.peerStorageBlobs.set(pubkey, { blob, receivedAt: now });
+        if (this.storage?.savePeerStorageBlob) {
+            this.safeStorage(() => this.storage.savePeerStorageBlob(pubkey, blob, now), 'savePeerStorageBlob');
+        }
+    }
+    handlePeerStorageRetrievalMessage(pubkey, payload) {
+        if (!this.peerStorageEnabled)
+            return;
+        let blob;
+        try {
+            blob = (0, peer_storage_1.decodePeerStorageRetrievalMessage)(payload).blob;
+        }
+        catch (err) {
+            this.emitStructuredLog('peer', 'peer_storage_retrieval_invalid', {
+                pubkey,
+                error: err instanceof Error ? err.message : String(err)
+            });
+            return;
+        }
+        this.retrievedPeerStorage.set(pubkey, { blob, receivedAt: Date.now() });
+        this.emit('peer_storage:retrieved', pubkey, blob);
+    }
+    peerQualifiesForStorage(pubkey) {
+        if (this.channelManager.isTrustedPeer(pubkey))
+            return true;
+        for (const channel of this.channelManager.listChannels()) {
+            const channelId = channel.getChannelId();
+            if (!channelId)
+                continue;
+            if (this.channelManager.getPeerForChannel(channelId) !== pubkey)
+                continue;
+            if (channel.getState() !== types_1.ChannelState.CLOSED)
+                return true;
+        }
+        return false;
+    }
+    sendPeerStorageOnConnect(pubkey) {
+        if (!this.peerStorageEnabled || !this.peerManager)
+            return;
+        let held = this.peerStorageBlobs.get(pubkey);
+        if (!held && this.storage?.loadPeerStorageBlob) {
+            try {
+                const loaded = this.storage.loadPeerStorageBlob(pubkey);
+                if (loaded) {
+                    held = loaded;
+                    this.peerStorageBlobs.set(pubkey, loaded);
+                }
+            }
+            catch (err) {
+                this.emitStructuredLog('peer', 'peer_storage_load_failed', {
+                    pubkey,
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            }
+        }
+        try {
+            if (held) {
+                this.peerManager.sendToPeer(pubkey, types_5.MessageType.PEER_STORAGE_RETRIEVAL, (0, peer_storage_1.encodePeerStorageRetrievalMessage)({ blob: held.blob }));
+            }
+            if (this.ourPeerStorageBlob && this.peerAdvertisesPeerStorage(pubkey)) {
+                this.peerManager.sendToPeer(pubkey, types_5.MessageType.PEER_STORAGE, (0, peer_storage_1.encodePeerStorageMessage)({ blob: this.ourPeerStorageBlob }));
+            }
+        }
+        catch {
+        }
+    }
+    peerAdvertisesPeerStorage(pubkey) {
+        const init = this.peerManager?.getPeer(pubkey)?.getRemoteInit();
+        return init ? init.features.hasFeature(flags_1.Feature.PROVIDE_STORAGE) : false;
+    }
+    distributePeerStorage(blob) {
+        if (blob.length > peer_storage_1.PEER_STORAGE_MAX_BYTES) {
+            throw new Error(`peer storage blob too large: ${blob.length} > ${peer_storage_1.PEER_STORAGE_MAX_BYTES} bytes`);
+        }
+        if (!this.peerStorageEnabled)
+            return 0;
+        this.ourPeerStorageBlob = Buffer.from(blob);
+        if (!this.peerManager)
+            return 0;
+        const payload = (0, peer_storage_1.encodePeerStorageMessage)({ blob: this.ourPeerStorageBlob });
+        let sent = 0;
+        for (const peer of this.peerManager.listPeers()) {
+            if (!this.peerAdvertisesPeerStorage(peer.pubkey))
+                continue;
+            try {
+                this.peerManager.sendToPeer(peer.pubkey, types_5.MessageType.PEER_STORAGE, payload);
+                sent++;
+            }
+            catch {
+            }
+        }
+        return sent;
+    }
+    getRetrievedPeerStorage() {
+        return [...this.retrievedPeerStorage.entries()].map(([peerPubkey, { blob, receivedAt }]) => ({
+            peerPubkey,
+            blob: Buffer.from(blob),
+            receivedAt
+        }));
+    }
     wirePeerManagerEvents() {
         if (!this.peerManager)
             return;
         this.peerManager.on('peer:connect', (pubkey) => {
+            this.sendPeerStorageOnConnect(pubkey);
             this.channelManager.handlePeerReconnected(pubkey);
             this.sendOwnGossipTo(pubkey);
             if (this.peerManager) {
@@ -802,17 +1052,19 @@ class LightningNode extends events_1.EventEmitter {
         if (!state.remoteBasepoints)
             return;
         const networkMap = {
-            [types_3.Network.MAINNET]: bitcoin.networks.bitcoin,
-            [types_3.Network.TESTNET]: bitcoin.networks.testnet,
-            [types_3.Network.REGTEST]: bitcoin.networks.regtest,
-            [types_3.Network.SIGNET]: bitcoin.networks.testnet
+            [types_4.Network.MAINNET]: bitcoin.networks.bitcoin,
+            [types_4.Network.TESTNET]: bitcoin.networks.testnet,
+            [types_4.Network.REGTEST]: bitcoin.networks.regtest,
+            [types_4.Network.SIGNET]: bitcoin.networks.testnet
         };
         const btcNetwork = networkMap[this.network] || bitcoin.networks.regtest;
-        const { address } = (0, types_7.isTaprootChannel)(state.channelType)
+        const { address } = (0, types_8.isTaprootChannel)(state.channelType)
             ? (0, funding_taproot_1.createTaprootFundingScript)(state.localBasepoints.fundingPubkey, state.remoteBasepoints.fundingPubkey, btcNetwork)
             : (0, funding_1.createFundingScript)(state.localBasepoints.fundingPubkey, state.remoteBasepoints.fundingPubkey, btcNetwork);
         const feePromise = this.feeEstimator
-            ? this.feeEstimator.estimateFee(6).then((f) => (f > 0 ? f : undefined))
+            ? this.feeEstimator
+                .estimateFee(6)
+                .then((f) => (f > 0 ? this.clampEstimatedFeeRate(f) : undefined))
             : Promise.resolve(undefined);
         feePromise
             .then((satsPerByte) => this.fundingProvider.buildFundingTransaction(address, state.fundingSatoshis, satsPerByte))
@@ -836,6 +1088,21 @@ class LightningNode extends events_1.EventEmitter {
     getNodeId() {
         return this.nodeId;
     }
+    signMessage(message) {
+        return (0, message_signing_1.signMessageWithKey)(message, this.nodePrivkey);
+    }
+    verifyMessage(message, signature) {
+        const result = (0, message_signing_1.verifyMessageSignature)(message, signature);
+        if (!result.valid || !result.pubkey) {
+            return { valid: false, pubkey: null, knownNode: false };
+        }
+        const knownNode = this.graph.getNode(result.pubkey) !== undefined;
+        return {
+            valid: true,
+            pubkey: result.pubkey.toString('hex'),
+            knownNode
+        };
+    }
     getNodeInfo() {
         return {
             nodeId: this.nodeId,
@@ -846,6 +1113,148 @@ class LightningNode extends events_1.EventEmitter {
             alias: this.alias
         };
     }
+    buildStaticChannelBackupData() {
+        const peerAddresses = new Map();
+        if (this.storage) {
+            for (const addr of this.storage.loadAllPeerAddresses()) {
+                const list = peerAddresses.get(addr.pubkey) ?? [];
+                list.push(`${addr.host}:${addr.port}`);
+                peerAddresses.set(addr.pubkey, list);
+            }
+        }
+        const channels = [];
+        const seen = new Set();
+        for (const channel of this.channelManager.listChannels()) {
+            const state = channel.getFullState();
+            if (!state.fundingTxid || !state.channelId)
+                continue;
+            if (state.state === types_1.ChannelState.CLOSED)
+                continue;
+            const idHex = state.channelId.toString('hex');
+            if (seen.has(idHex))
+                continue;
+            const peer = this.channelManager.getPeerForChannel(state.channelId);
+            if (!peer)
+                continue;
+            seen.add(idHex);
+            channels.push({
+                channelId: idHex,
+                peerNodeId: peer,
+                peerAddresses: peerAddresses.get(peer) ?? [],
+                fundingTxid: state.fundingTxid.toString('hex'),
+                fundingOutputIndex: state.fundingOutputIndex,
+                fundingSatoshis: state.fundingSatoshis.toString(),
+                channelKeyIndex: channel.channelKeyIndex,
+                channelType: state.channelType ? state.channelType.toString('hex') : '',
+                role: state.role === types_1.ChannelRole.OPENER ? 'OPENER' : 'ACCEPTOR',
+                isTaproot: (0, types_8.isTaprootChannel)(state.channelType),
+                isAnchor: (0, types_8.isAnchorChannel)(state.channelType)
+            });
+        }
+        return { network: this.network, channels };
+    }
+    async recoverFromStaticChannelBackup(entries) {
+        const recovering = [];
+        const skipped = [];
+        for (const entry of entries) {
+            const channelId = Buffer.from(entry.channelId, 'hex');
+            if (channelId.length !== 32 ||
+                channelId.toString('hex') !== entry.channelId.toLowerCase()) {
+                skipped.push({
+                    channelId: entry.channelId,
+                    reason: 'invalid channelId (expected 32-byte hex)'
+                });
+                continue;
+            }
+            if (this.channelManager.getChannel(channelId)) {
+                skipped.push({
+                    channelId: entry.channelId,
+                    reason: 'channel already exists'
+                });
+                continue;
+            }
+            const material = this.channelManager.getRecoveryChannelMaterial(entry.channelKeyIndex);
+            const stateParams = {
+                temporaryChannelId: Buffer.from(channelId),
+                fundingSatoshis: BigInt(entry.fundingSatoshis),
+                pushMsat: 0n,
+                localConfig: material.localConfig,
+                localBasepoints: material.basepoints,
+                localPerCommitmentSeed: material.perCommitmentSeed
+            };
+            const state = entry.role === 'ACCEPTOR'
+                ? (0, channel_state_1.createAcceptorState)({
+                    ...stateParams,
+                    remoteBasepoints: material.basepoints,
+                    remoteConfig: { ...types_1.DEFAULT_CHANNEL_CONFIG }
+                })
+                : (0, channel_state_1.createOpenerState)(stateParams);
+            state.remoteBasepoints = null;
+            state.channelId = channelId;
+            state.fundingTxid = Buffer.from(entry.fundingTxid, 'hex');
+            state.fundingOutputIndex = entry.fundingOutputIndex;
+            state.channelType = entry.channelType
+                ? Buffer.from(entry.channelType, 'hex')
+                : null;
+            state.localCommitmentNumber = 0n;
+            state.remoteCommitmentNumber = 0n;
+            state.localBalanceMsat = 0n;
+            state.remoteBalanceMsat = 0n;
+            state.announceChannel = false;
+            state.state = types_1.ChannelState.ERRORED;
+            state.dataLossDetected = true;
+            const channel = new channel_1.Channel(state);
+            channel.channelKeyIndex = entry.channelKeyIndex;
+            this.channelManager.restoreChannel(channel, entry.peerNodeId, entry.channelKeyIndex);
+            this.persistChannel(channelId);
+            recovering.push(entry.channelId);
+            this.emitStructuredLog('channel', 'recovery_started', {
+                channelId: entry.channelId,
+                peerNodeId: entry.peerNodeId,
+                fundingTxid: entry.fundingTxid,
+                fundingOutputIndex: entry.fundingOutputIndex,
+                channelKeyIndex: entry.channelKeyIndex
+            });
+            if (this.chainWatcher) {
+                try {
+                    await this.watchRecoveredFundingOutput(channelId, state);
+                }
+                catch (err) {
+                    this.emit('node:error', {
+                        code: 'RECOVERY_WATCH_FAILED',
+                        channelId,
+                        message: `Failed to watch recovered funding output: ${err.message}`,
+                        timestamp: Date.now()
+                    });
+                }
+            }
+            if (this.peerManager && entry.peerAddresses.length > 0) {
+                void this.contactRecoveryPeer(entry.peerNodeId, entry.peerAddresses);
+            }
+        }
+        return { recovering, skipped };
+    }
+    async contactRecoveryPeer(peerNodeId, addresses) {
+        for (const address of addresses) {
+            const sep = address.lastIndexOf(':');
+            if (sep <= 0)
+                continue;
+            const host = address.slice(0, sep).replace(/^\[|\]$/g, '');
+            const port = parseInt(address.slice(sep + 1), 10);
+            if (!Number.isFinite(port) || port <= 0)
+                continue;
+            try {
+                await this.connectPeer(peerNodeId, host, port);
+                return;
+            }
+            catch {
+            }
+        }
+        this.emitStructuredLog('peer', 'recovery_connect_failed', {
+            peerNodeId,
+            addresses
+        });
+    }
     getSweepDestinationScript() {
         if (this.sweepDestinationScript) {
             return this.sweepDestinationScript;
@@ -857,6 +1266,92 @@ class LightningNode extends events_1.EventEmitter {
             return Buffer.alloc(22);
         }
     }
+    getBitcoinNetwork() {
+        if (this.network === types_4.Network.MAINNET)
+            return bitcoin.networks.bitcoin;
+        if (this.network === types_4.Network.REGTEST)
+            return bitcoin.networks.regtest;
+        return bitcoin.networks.testnet;
+    }
+    initWatchtowerClient(towers) {
+        if (towers.length === 0) {
+            this.watchtowerClient = null;
+            return;
+        }
+        const btcNetwork = this.getBitcoinNetwork();
+        const store = this.storage &&
+            typeof this.storage.saveWatchtowerSession ===
+                'function'
+            ? this.storage
+            : undefined;
+        this.watchtowerClient = new watchtower_1.WatchtowerClient({
+            localPrivateKey: this.nodePrivkey,
+            chainHash: (0, watchtower_1.chainHashForNetwork)(btcNetwork),
+            network: btcNetwork,
+            towers,
+            store,
+            socks5Proxy: this.socks5Proxy ?? undefined
+        });
+        this.watchtowerClient.on('log', (entry) => {
+            const event = String(entry.event ?? 'log');
+            this.emitStructuredLog('watchtower', event, entry);
+        });
+    }
+    backupRevokedStateToTowers(channelId, perCommitmentSecret, revokedTx) {
+        const client = this.watchtowerClient;
+        if (!client || !client.enabled)
+            return;
+        try {
+            const channel = this.channelManager.getChannel(channelId);
+            if (!channel)
+                return;
+            const state = channel.getFullState();
+            if (!state.remoteBasepoints)
+                return;
+            const perCh = this.channelManager.getMonitorSigningKeys(channelId);
+            const revocationBasepointSecret = perCh?.revocationBasepointSecret ?? this.revocationBasepointSecret;
+            if (!revocationBasepointSecret)
+                return;
+            const paymentBasepointSecret = perCh?.paymentBasepointSecret ?? this.paymentBasepointSecret;
+            const btcNetwork = this.getBitcoinNetwork();
+            const ctx = {
+                channelId: channelId.toString('hex'),
+                revokedTx: bitcoin.Transaction.fromBuffer(revokedTx),
+                perCommitmentSecret,
+                revocationBasepoint: state.localBasepoints.revocationBasepoint,
+                revocationBasepointSecret,
+                remoteDelayedBasepoint: state.remoteBasepoints.delayedPaymentBasepoint,
+                toSelfDelay: state.localConfig.toSelfDelay,
+                isAnchor: (0, types_8.isAnchorChannel)(state.channelType),
+                localPaymentPubkey: state.localBasepoints.paymentBasepoint,
+                paymentBasepointSecret,
+                sweepScript: this.getSweepDestinationScript(),
+                network: btcNetwork
+            };
+            client.backupRevokedState(ctx);
+        }
+        catch (err) {
+            this.emitStructuredLog('watchtower', 'backup_context_failed', {
+                channelId: channelId.toString('hex'),
+                error: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    addWatchtower(uri) {
+        if (!this.watchtowerClient) {
+            this.initWatchtowerClient([uri]);
+            const client = this.watchtowerClient;
+            void client?.start();
+            return;
+        }
+        this.watchtowerClient.addTower(uri);
+    }
+    removeWatchtower(uri) {
+        this.watchtowerClient?.removeTower(uri);
+    }
+    getWatchtowers() {
+        return this.watchtowerClient ? this.watchtowerClient.getHealth() : [];
+    }
     setSweepDestinationScript(destinationScript) {
         this.sweepDestinationScript = destinationScript;
         this.chainWatcher?.setDestinationScript(destinationScript);
@@ -884,7 +1379,7 @@ class LightningNode extends events_1.EventEmitter {
         let feeRatePerVbyte = opts?.feeRatePerVbyte ?? 0;
         if (feeRatePerVbyte <= 0 && this.feeEstimator) {
             try {
-                feeRatePerVbyte = await this.feeEstimator.estimateFee(6);
+                feeRatePerVbyte = this.clampEstimatedFeeRate(await this.feeEstimator.estimateFee(6));
             }
             catch {
             }
@@ -918,10 +1413,10 @@ class LightningNode extends events_1.EventEmitter {
     }
     getFundingAddress() {
         const networkMap = {
-            [types_3.Network.MAINNET]: bitcoin.networks.bitcoin,
-            [types_3.Network.TESTNET]: bitcoin.networks.testnet,
-            [types_3.Network.REGTEST]: bitcoin.networks.regtest,
-            [types_3.Network.SIGNET]: bitcoin.networks.testnet
+            [types_4.Network.MAINNET]: bitcoin.networks.bitcoin,
+            [types_4.Network.TESTNET]: bitcoin.networks.testnet,
+            [types_4.Network.REGTEST]: bitcoin.networks.regtest,
+            [types_4.Network.SIGNET]: bitcoin.networks.testnet
         };
         const btcNetwork = networkMap[this.network] || bitcoin.networks.regtest;
         const { address } = bitcoin.payments.p2wpkh({
@@ -949,6 +1444,13 @@ class LightningNode extends events_1.EventEmitter {
         const pubkeyErr = (0, validation_2.validateHexPubkey)(pubkey, 'pubkey');
         if (pubkeyErr)
             throw new Error(pubkeyErr);
+        if (host === undefined && port === undefined) {
+            await this.connectPeerById(pubkey);
+            return;
+        }
+        if (host === undefined || port === undefined) {
+            throw new Error('host and port must be provided together (omit both to resolve from gossip/DNS)');
+        }
         const hostErr = (0, validation_2.validateHost)(host);
         if (hostErr)
             throw new Error(hostErr);
@@ -957,6 +1459,58 @@ class LightningNode extends events_1.EventEmitter {
             throw new Error(portErr);
         await this.peerManager.connectPeer(pubkey, host, port);
     }
+    async connectPeerById(pubkey) {
+        const attempts = [];
+        const isTor = (a) => a.type === types_2.ADDRESS_TYPE_TORV2 || a.type === types_2.ADDRESS_TYPE_TORV3;
+        const announced = this.graph.getNode(Buffer.from(pubkey, 'hex'))?.announcement?.addresses ??
+            [];
+        let skippedTor = 0;
+        const candidates = [];
+        for (const addr of announced) {
+            if (isTor(addr) && !this.socks5Proxy) {
+                skippedTor++;
+                continue;
+            }
+            const dialable = (0, messages_1.nodeAddressToHostPort)(addr);
+            if (dialable)
+                candidates.push(dialable);
+        }
+        for (const { host, port } of candidates) {
+            try {
+                await this.peerManager.connectPeer(pubkey, host, port);
+                return;
+            }
+            catch (err) {
+                attempts.push(`graph ${host}:${port} (${err instanceof Error ? err.message : String(err)})`);
+            }
+        }
+        if (skippedTor > 0) {
+            attempts.push(`skipped ${skippedTor} Tor address(es): no socks5Proxy configured`);
+        }
+        if (candidates.length === 0) {
+            let seedPeers = [];
+            try {
+                seedPeers = await this.bootstrapPeers();
+            }
+            catch (err) {
+                attempts.push(`DNS bootstrap failed (${err instanceof Error ? err.message : String(err)})`);
+            }
+            const matches = seedPeers.filter((p) => p.pubkey.toString('hex') === pubkey);
+            if (matches.length === 0) {
+                attempts.push('DNS bootstrap returned no address for this node id');
+            }
+            for (const peer of matches) {
+                try {
+                    await this.peerManager.connectPeer(pubkey, peer.host, peer.port);
+                    return;
+                }
+                catch (err) {
+                    attempts.push(`dns ${peer.host}:${peer.port} (${err instanceof Error ? err.message : String(err)})`);
+                }
+            }
+        }
+        throw new Error(`Unable to resolve a connection to ${pubkey}: ${attempts.join('; ')}`);
+    }
     disconnectPeer(pubkey) {
         if (!this.peerManager) {
             throw new Error('Networking is not enabled');
@@ -1033,6 +1587,13 @@ class LightningNode extends events_1.EventEmitter {
         });
     }
     async startChainWatcher() {
+        if (this.watchtowerClient) {
+            this.watchtowerClient.start().catch((err) => {
+                this.emitStructuredLog('watchtower', 'start_failed', {
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            });
+        }
         if (this.chainWatcher) {
             this.wireChainWatcherEvents();
             await this.chainWatcher.start();
@@ -1050,10 +1611,10 @@ class LightningNode extends events_1.EventEmitter {
         if (!this.chainWatcher)
             return;
         const networkMap = {
-            [types_3.Network.MAINNET]: bitcoin.networks.bitcoin,
-            [types_3.Network.TESTNET]: bitcoin.networks.testnet,
-            [types_3.Network.REGTEST]: bitcoin.networks.regtest,
-            [types_3.Network.SIGNET]: bitcoin.networks.testnet
+            [types_4.Network.MAINNET]: bitcoin.networks.bitcoin,
+            [types_4.Network.TESTNET]: bitcoin.networks.testnet,
+            [types_4.Network.REGTEST]: bitcoin.networks.regtest,
+            [types_4.Network.SIGNET]: bitcoin.networks.testnet
         };
         const btcNetwork = networkMap[this.network] || bitcoin.networks.regtest;
         for (const channel of this.channelManager.listChannels()) {
@@ -1066,10 +1627,10 @@ class LightningNode extends events_1.EventEmitter {
                     continue;
                 if (monitor) {
                     for (const output of monitor.getTrackedOutputs()) {
-                        if (output.status === types_6.OutputStatus.IRREVOCABLY_RESOLVED)
+                        if (output.status === types_7.OutputStatus.IRREVOCABLY_RESOLVED)
                             continue;
                         try {
-                            const seedTxid = output.status === types_6.OutputStatus.SPEND_CONFIRMED
+                            const seedTxid = output.status === types_7.OutputStatus.SPEND_CONFIRMED
                                 ? output.resolutionTxid
                                 : undefined;
                             const seedHeight = seedTxid !== undefined ? output.confirmationHeight : undefined;
@@ -1093,10 +1654,10 @@ class LightningNode extends events_1.EventEmitter {
                     continue;
                 if (monitor) {
                     for (const output of monitor.getTrackedOutputs()) {
-                        if (output.status === types_6.OutputStatus.IRREVOCABLY_RESOLVED)
+                        if (output.status === types_7.OutputStatus.IRREVOCABLY_RESOLVED)
                             continue;
                         try {
-                            const seedTxid = output.status === types_6.OutputStatus.SPEND_CONFIRMED
+                            const seedTxid = output.status === types_7.OutputStatus.SPEND_CONFIRMED
                                 ? output.resolutionTxid
                                 : undefined;
                             const seedHeight = seedTxid !== undefined ? output.confirmationHeight : undefined;
@@ -1107,8 +1668,22 @@ class LightningNode extends events_1.EventEmitter {
                     }
                 }
             }
-            if (!state.remoteBasepoints)
+            if (!state.remoteBasepoints) {
+                if (state.dataLossDetected && state.fundingTxid) {
+                    try {
+                        await this.watchRecoveredFundingOutput(state.channelId || state.temporaryChannelId, state);
+                    }
+                    catch (err) {
+                        this.emit('node:error', {
+                            code: 'RECOVERY_WATCH_FAILED',
+                            channelId: state.channelId || state.temporaryChannelId,
+                            message: `Failed to watch recovered funding output: ${err.message}`,
+                            timestamp: Date.now()
+                        });
+                    }
+                }
                 continue;
+            }
             const { p2wshOutput } = (0, funding_1.createFundingScript)(state.localBasepoints.fundingPubkey, state.remoteBasepoints.fundingPubkey, btcNetwork);
             const inflight = state.spliceInFlight;
             if (inflight) {
@@ -1130,6 +1705,21 @@ class LightningNode extends events_1.EventEmitter {
             await this.chainWatcher.watchFundingOutput(state.channelId || state.temporaryChannelId, txidHex, state.fundingOutputIndex, state.minimumDepth ?? 3, p2wshOutput);
         }
     }
+    async watchRecoveredFundingOutput(channelId, state) {
+        if (!this.chainWatcher || !this._chainBackend) {
+            throw new Error('Chain backend is not available');
+        }
+        if (!state.fundingTxid) {
+            throw new Error('Recovered channel has no funding txid');
+        }
+        const txidHex = Buffer.from(state.fundingTxid).reverse().toString('hex');
+        const rawTx = await this._chainBackend.getTransaction(txidHex);
+        const fundingTx = bitcoin.Transaction.fromBuffer(rawTx);
+        if (state.fundingOutputIndex >= fundingTx.outs.length) {
+            throw new Error(`Funding output index ${state.fundingOutputIndex} out of range for tx ${txidHex}`);
+        }
+        await this.chainWatcher.watchFundingOutput(channelId, txidHex, state.fundingOutputIndex, state.minimumDepth || 1, Buffer.from(fundingTx.outs[state.fundingOutputIndex].script));
+    }
     async bootstrapPeers(config) {
         return (0, bootstrap_1.bootstrapPeers)(config);
     }
@@ -1198,6 +1788,14 @@ class LightningNode extends events_1.EventEmitter {
             clearInterval(this._gossipRefreshTimer);
             this._gossipRefreshTimer = undefined;
         }
+        if (this.autoRebalanceTimer) {
+            clearInterval(this.autoRebalanceTimer);
+            this.autoRebalanceTimer = null;
+        }
+        if (this.autoTuneFeesTimer) {
+            clearInterval(this.autoTuneFeesTimer);
+            this.autoTuneFeesTimer = null;
+        }
         for (const t of this._reconnectTimers) {
             clearTimeout(t);
         }
@@ -1214,6 +1812,9 @@ class LightningNode extends events_1.EventEmitter {
         if (this.chainWatcher) {
             this.chainWatcher.stop();
         }
+        if (this.watchtowerClient) {
+            this.watchtowerClient.stop();
+        }
         if (this.peerManager) {
             this.peerManager.destroy();
         }
@@ -1315,8 +1916,8 @@ class LightningNode extends events_1.EventEmitter {
         const max = this.resourceConfig.maxCompletedPayments;
         let pruned = 0;
         for (const [hash, payment] of this.payments) {
-            if (payment.status === types_5.PaymentStatus.COMPLETED ||
-                payment.status === types_5.PaymentStatus.FAILED) {
+            if (payment.status === types_6.PaymentStatus.COMPLETED ||
+                payment.status === types_6.PaymentStatus.FAILED) {
                 const age = now - (payment.completedAt || payment.createdAt);
                 if (age > ttl) {
                     this.payments.delete(hash);
@@ -1327,8 +1928,8 @@ class LightningNode extends events_1.EventEmitter {
         }
         const completed = [];
         for (const entry of this.payments) {
-            if (entry[1].status === types_5.PaymentStatus.COMPLETED ||
-                entry[1].status === types_5.PaymentStatus.FAILED) {
+            if (entry[1].status === types_6.PaymentStatus.COMPLETED ||
+                entry[1].status === types_6.PaymentStatus.FAILED) {
                 completed.push(entry);
             }
         }
@@ -1444,6 +2045,217 @@ class LightningNode extends events_1.EventEmitter {
         }
         return { ok: true };
     }
+    setChannelPolicy(channelId, policy) {
+        this.validateChannelPolicyFields(policy);
+        let targets;
+        if (channelId === 'all') {
+            targets = this.channelManager
+                .listChannels()
+                .map((ch) => ch.getChannelId())
+                .filter((id) => id !== null);
+        }
+        else {
+            const cidErr = (0, validation_2.validateBuffer)(channelId, 32, 'channelId');
+            if (cidErr)
+                throw new Error(cidErr);
+            if (!this.channelManager.getChannel(channelId)) {
+                throw new Error(`Channel not found: ${channelId.toString('hex')}`);
+            }
+            targets = [channelId];
+        }
+        for (const target of targets) {
+            const hex = target.toString('hex');
+            const merged = {
+                ...this.channelPolicies.get(hex),
+                ...policy
+            };
+            if (merged.htlcMinimumMsat !== undefined &&
+                merged.htlcMaximumMsat !== undefined &&
+                merged.htlcMinimumMsat > merged.htlcMaximumMsat) {
+                throw new Error(`htlcMinimumMsat (${merged.htlcMinimumMsat}) exceeds htlcMaximumMsat (${merged.htlcMaximumMsat})`);
+            }
+            this.channelPolicies.set(hex, merged);
+            this.safeStorage(() => this.storage.saveChannelPolicy?.(hex, LightningNode.serializeChannelPolicy(merged)), 'saveChannelPolicy');
+            this.regenerateChannelUpdateForPolicy(target);
+            this.emitStructuredLog('channel', 'policy_updated', {
+                channelId: hex,
+                ...LightningNode.serializeChannelPolicy(merged)
+            });
+        }
+    }
+    getChannelPolicy(channelId) {
+        const channel = this.channelManager.getChannel(channelId);
+        if (!channel)
+            return null;
+        const state = channel.getFullState();
+        const override = this.channelPolicies.get(channelId.toString('hex'));
+        const capacityMsat = state.fundingSatoshis * 1000n;
+        const defaultHtlcMax = state.localConfig.maxHtlcValueInFlightMsat > capacityMsat
+            ? capacityMsat
+            : state.localConfig.maxHtlcValueInFlightMsat;
+        return {
+            feeBaseMsat: override?.feeBaseMsat ?? this.forwardingFeeBaseMsat,
+            feeProportionalMillionths: override?.feeProportionalMillionths ?? this.forwardingFeePropMillionths,
+            cltvExpiryDelta: override?.cltvExpiryDelta ?? this.forwardingCltvDelta,
+            htlcMinimumMsat: override?.htlcMinimumMsat ?? state.localConfig.htlcMinimumMsat,
+            htlcMaximumMsat: override?.htlcMaximumMsat ?? defaultHtlcMax,
+            source: override && Object.keys(override).length > 0 ? 'override' : 'default'
+        };
+    }
+    getForwardingPolicyForChannel(channelId) {
+        const override = channelId
+            ? this.channelPolicies.get(channelId.toString('hex'))
+            : undefined;
+        return {
+            feeBaseMsat: override?.feeBaseMsat ?? this.forwardingFeeBaseMsat,
+            feeProportionalMillionths: override?.feeProportionalMillionths ?? this.forwardingFeePropMillionths,
+            cltvExpiryDelta: override?.cltvExpiryDelta ?? this.forwardingCltvDelta
+        };
+    }
+    validateChannelPolicyFields(policy) {
+        if (policy.feeBaseMsat === undefined &&
+            policy.feeProportionalMillionths === undefined &&
+            policy.cltvExpiryDelta === undefined &&
+            policy.htlcMinimumMsat === undefined &&
+            policy.htlcMaximumMsat === undefined) {
+            throw new Error('policy must set at least one field');
+        }
+        if (policy.feeBaseMsat !== undefined) {
+            if (!Number.isInteger(policy.feeBaseMsat) ||
+                policy.feeBaseMsat < 0 ||
+                policy.feeBaseMsat > 0xffffffff) {
+                throw new Error(`feeBaseMsat must be an integer in [0, 4294967295], got ${policy.feeBaseMsat}`);
+            }
+        }
+        if (policy.feeProportionalMillionths !== undefined) {
+            if (!Number.isInteger(policy.feeProportionalMillionths) ||
+                policy.feeProportionalMillionths < 0 ||
+                policy.feeProportionalMillionths > 0xffffffff) {
+                throw new Error(`feeProportionalMillionths must be an integer in [0, 4294967295], got ${policy.feeProportionalMillionths}`);
+            }
+        }
+        if (policy.cltvExpiryDelta !== undefined) {
+            if (!Number.isInteger(policy.cltvExpiryDelta) ||
+                policy.cltvExpiryDelta < 1 ||
+                policy.cltvExpiryDelta > 0xffff) {
+                throw new Error(`cltvExpiryDelta must be an integer in [1, 65535] (>= 18 recommended), got ${policy.cltvExpiryDelta}`);
+            }
+        }
+        if (policy.htlcMinimumMsat !== undefined &&
+            (typeof policy.htlcMinimumMsat !== 'bigint' ||
+                policy.htlcMinimumMsat < 0n)) {
+            throw new Error(`htlcMinimumMsat must be a non-negative bigint, got ${policy.htlcMinimumMsat}`);
+        }
+        if (policy.htlcMaximumMsat !== undefined &&
+            (typeof policy.htlcMaximumMsat !== 'bigint' ||
+                policy.htlcMaximumMsat < 0n)) {
+            throw new Error(`htlcMaximumMsat must be a non-negative bigint, got ${policy.htlcMaximumMsat}`);
+        }
+        if (policy.htlcMinimumMsat !== undefined &&
+            policy.htlcMaximumMsat !== undefined &&
+            policy.htlcMinimumMsat > policy.htlcMaximumMsat) {
+            throw new Error(`htlcMinimumMsat (${policy.htlcMinimumMsat}) exceeds htlcMaximumMsat (${policy.htlcMaximumMsat})`);
+        }
+    }
+    static serializeChannelPolicy(policy) {
+        const out = {};
+        if (policy.feeBaseMsat !== undefined)
+            out.feeBaseMsat = policy.feeBaseMsat;
+        if (policy.feeProportionalMillionths !== undefined)
+            out.feeProportionalMillionths = policy.feeProportionalMillionths;
+        if (policy.cltvExpiryDelta !== undefined)
+            out.cltvExpiryDelta = policy.cltvExpiryDelta;
+        if (policy.htlcMinimumMsat !== undefined)
+            out.htlcMinimumMsat = policy.htlcMinimumMsat.toString();
+        if (policy.htlcMaximumMsat !== undefined)
+            out.htlcMaximumMsat = policy.htlcMaximumMsat.toString();
+        return out;
+    }
+    regenerateChannelUpdateForPolicy(channelId) {
+        const hex = channelId.toString('hex');
+        const gossip = this._ownChannelGossip.get(hex);
+        if (gossip) {
+            let timestamp = Math.floor(Date.now() / 1000);
+            try {
+                timestamp = Math.max(timestamp, (0, messages_1.decodeChannelUpdateMessage)(gossip.update).timestamp + 1);
+            }
+            catch {
+            }
+            const refreshed = this.refreshChannelUpdate(gossip.update, timestamp, channelId);
+            if (!refreshed)
+                return;
+            this._ownChannelGossip.set(hex, {
+                announcement: gossip.announcement,
+                update: refreshed
+            });
+            try {
+                this.graph.applyChannelUpdate((0, messages_1.decodeChannelUpdateMessage)(refreshed));
+            }
+            catch {
+            }
+            this.broadcastOwnGossip();
+            return;
+        }
+        const payload = this.buildDirectChannelUpdate(channelId);
+        if (!payload)
+            return;
+        const peer = this.channelManager.getPeerForChannel(channelId);
+        if (!peer)
+            return;
+        if (this.peerManager) {
+            try {
+                this.peerManager.sendToPeer(peer, types_5.MessageType.CHANNEL_UPDATE, payload);
+            }
+            catch {
+            }
+        }
+        else {
+            this.emit('message:outbound', peer, types_5.MessageType.CHANNEL_UPDATE, payload);
+        }
+    }
+    buildDirectChannelUpdate(channelId) {
+        const channel = this.channelManager.getChannel(channelId);
+        if (!channel)
+            return null;
+        const state = channel.getFullState();
+        const scid = state.shortChannelId ?? state.scidAlias;
+        if (!scid)
+            return null;
+        const peerHex = this.channelManager.getPeerForChannel(channelId);
+        if (!peerHex)
+            return null;
+        const policy = this.getChannelPolicy(channelId);
+        if (!policy)
+            return null;
+        try {
+            const { encodeChannelUpdateMessage } = require('../gossip/messages');
+            const ourNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
+            const peerNodeId = Buffer.from(peerHex, 'hex');
+            const capacityMsat = state.fundingSatoshis * 1000n;
+            const htlcMaxMsat = policy.htlcMaximumMsat > capacityMsat
+                ? capacityMsat
+                : policy.htlcMaximumMsat;
+            const payload = encodeChannelUpdateMessage({
+                signature: Buffer.alloc(64),
+                chainHash: this.acceptableChainHashes[0] ?? types_1.BITCOIN_CHAIN_HASH,
+                shortChannelId: scid,
+                timestamp: Math.floor(Date.now() / 1000),
+                messageFlags: 0x01,
+                channelFlags: Buffer.compare(ourNodeId, peerNodeId) < 0 ? 0 : 1,
+                cltvExpiryDelta: policy.cltvExpiryDelta,
+                htlcMinimumMsat: policy.htlcMinimumMsat,
+                feeBaseMsat: policy.feeBaseMsat,
+                feeProportionalMillionths: policy.feeProportionalMillionths,
+                htlcMaximumMsat: htlcMaxMsat
+            });
+            const sig = (0, validation_1.signChannelUpdate)(payload, this.nodePrivkey);
+            sig.copy(payload, 0);
+            return payload;
+        }
+        catch {
+            return null;
+        }
+    }
     forceCloseChannel(channelId, destinationScript) {
         const result = this.channelManager.forceClose(channelId, destinationScript, this.resolveForceCloseFeeRatePerVbyte());
         if (!result.ok) {
@@ -1661,6 +2473,316 @@ class LightningNode extends events_1.EventEmitter {
         });
         return this.liquidityAdvisor.analyze(snapshots);
     }
+    planRebalanceRecommendations(minImbalancePct) {
+        const snapshots = this.listChannels().map((ch) => ({
+            channelId: ch.channelId.toString('hex'),
+            state: ch.state,
+            localBalanceMsat: ch.localBalanceMsat,
+            remoteBalanceMsat: ch.remoteBalanceMsat,
+            capacitySats: Number(ch.fundingSatoshis),
+            peerPubkey: ch.peerPubkey
+        }));
+        const plans = (0, rebalance_planner_1.planRebalances)(snapshots, {
+            minImbalancePct: minImbalancePct ?? this.autoRebalanceConfig.minImbalancePct
+        });
+        const clamped = [];
+        for (const plan of plans) {
+            const fromCh = this.channelManager.getChannel(Buffer.from(plan.fromChannelId, 'hex'));
+            const toCh = this.channelManager.getChannel(Buffer.from(plan.toChannelId, 'hex'));
+            if (!fromCh || !toCh)
+                continue;
+            const outCapMsat = fromCh.getFullState().remoteConfig.maxHtlcValueInFlightMsat;
+            const inCapMsat = toCh.getFullState().localConfig.maxHtlcValueInFlightMsat;
+            const capMsat = outCapMsat < inCapMsat ? outCapMsat : inCapMsat;
+            const maxAmountSats = (capMsat * 99n) / 100n / 1000n;
+            const amountSats = plan.amountSats < maxAmountSats ? plan.amountSats : maxAmountSats;
+            if (amountSats < rebalance_planner_1.MIN_REBALANCE_SATS)
+                continue;
+            clamped.push({ ...plan, amountSats });
+        }
+        return clamped;
+    }
+    async rebalanceChannel(options) {
+        const { fromChannelId, toChannelId, amountSats, maxFeeSats } = options;
+        const cidErr = (0, validation_2.validateBuffer)(fromChannelId, 32, 'fromChannelId') ||
+            (0, validation_2.validateBuffer)(toChannelId, 32, 'toChannelId');
+        if (cidErr)
+            throw new Error(cidErr);
+        if (fromChannelId.equals(toChannelId)) {
+            throw new Error('fromChannelId and toChannelId must differ');
+        }
+        if (amountSats <= 0n)
+            throw new Error('amountSats must be positive');
+        if (maxFeeSats < 0n)
+            throw new Error('maxFeeSats must be non-negative');
+        const fromChannel = this.channelManager.getChannel(fromChannelId);
+        if (!fromChannel || fromChannel.getState() !== types_1.ChannelState.NORMAL) {
+            throw new Error(`from channel not found or not NORMAL: ${fromChannelId.toString('hex')}`);
+        }
+        const toChannel = this.channelManager.getChannel(toChannelId);
+        if (!toChannel || toChannel.getState() !== types_1.ChannelState.NORMAL) {
+            throw new Error(`to channel not found or not NORMAL: ${toChannelId.toString('hex')}`);
+        }
+        const amountMsat = amountSats * 1000n;
+        const maxFeeMsat = maxFeeSats * 1000n;
+        const fromState = fromChannel.getFullState();
+        const toState = toChannel.getFullState();
+        if (fromState.localBalanceMsat < amountMsat) {
+            throw new Error('insufficient local balance on from channel');
+        }
+        if (toState.remoteBalanceMsat < amountMsat) {
+            throw new Error('insufficient inbound capacity on to channel');
+        }
+        if (amountMsat > toState.localConfig.maxHtlcValueInFlightMsat) {
+            throw new Error('amount exceeds our max_htlc_value_in_flight on the to channel');
+        }
+        const fromScid = fromState.shortChannelId ?? fromState.scidAlias;
+        if (!fromScid) {
+            throw new Error('from channel has no SCID or alias yet');
+        }
+        const fromPeerHex = this.channelManager.getPeerForChannel(fromChannelId);
+        if (!fromPeerHex)
+            throw new Error('from channel has no known peer');
+        const toHint = this.buildRoutingHintForChannel(toChannel);
+        if (!toHint) {
+            throw new Error('to channel has no usable routing hint (SCID/alias)');
+        }
+        const excluded = new Set();
+        for (const channel of this.channelManager.listChannels()) {
+            const id = channel.getChannelId();
+            if (id && id.equals(fromChannelId))
+                continue;
+            const st = channel.getFullState();
+            if (st.shortChannelId)
+                excluded.add(st.shortChannelId.toString('hex'));
+            if (st.scidAlias)
+                excluded.add(st.scidAlias.toString('hex'));
+            if (st.remoteScidAlias) {
+                excluded.add(st.remoteScidAlias.toString('hex'));
+            }
+        }
+        const ourNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
+        const finalCltvExpiry = types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
+        const toPeerFeeMsat = (0, pathfinding_1.calculateFee)(amountMsat, toHint.feeBaseMsat, toHint.feeProportionalMillionths);
+        const subRoute = (0, pathfinding_1.findRoute)(this.graph, ourNodeId, toHint.pubkey, amountMsat + toPeerFeeMsat, finalCltvExpiry + toHint.cltvExpiryDelta, undefined, excluded, this.missionControl, undefined, undefined, undefined, [
+            {
+                shortChannelId: fromScid,
+                peer: Buffer.from(fromPeerHex, 'hex'),
+                outboundMsat: fromState.localBalanceMsat
+            }
+        ]);
+        if (!subRoute) {
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_ROUTE, 'No circular route from fromChannel back to toChannel');
+        }
+        if (!subRoute.hops[0].shortChannelId.equals(fromScid)) {
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_ROUTE, 'Route does not leave over the requested from channel');
+        }
+        const totalFeeMsat = subRoute.totalAmountMsat - amountMsat;
+        if (totalFeeMsat > maxFeeMsat) {
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.FEE_EXCEEDS_MAX, `Rebalance fee ${totalFeeMsat} msat exceeds cap ${maxFeeMsat} msat`);
+        }
+        if (subRoute.totalAmountMsat > fromState.remoteConfig.maxHtlcValueInFlightMsat) {
+            throw new Error('amount plus fees exceeds the peer max_htlc_value_in_flight on the from channel');
+        }
+        const invoice = this.createInvoice({
+            amountMsat,
+            description: 'beignet circular rebalance',
+            minFinalCltvExpiry: finalCltvExpiry
+        });
+        const hops = [
+            ...subRoute.hops,
+            {
+                pubkey: ourNodeId,
+                shortChannelId: toHint.shortChannelId,
+                amountToForwardMsat: amountMsat,
+                outgoingCltvValue: finalCltvExpiry,
+                cltvExpiryDelta: toHint.cltvExpiryDelta,
+                feeBaseMsat: 0,
+                feeProportionalMillionths: 0
+            }
+        ];
+        this.emitStructuredLog('payment', 'rebalance_started', {
+            fromChannelId: fromChannelId.toString('hex'),
+            toChannelId: toChannelId.toString('hex'),
+            amountMsat: amountMsat.toString(),
+            feeMsat: totalFeeMsat.toString(),
+            hops: hops.length
+        });
+        this.sendPaymentToRoute({ hops }, invoice.paymentHash, finalCltvExpiry, invoice.paymentSecret, amountMsat);
+        await this.waitForPayment(invoice.paymentHash, options.timeoutMs ?? 60000);
+        this.emitStructuredLog('payment', 'rebalance_succeeded', {
+            fromChannelId: fromChannelId.toString('hex'),
+            toChannelId: toChannelId.toString('hex'),
+            amountMsat: amountMsat.toString(),
+            feeMsat: totalFeeMsat.toString()
+        });
+        return {
+            paymentHash: invoice.paymentHash,
+            amountMsat,
+            feeMsat: totalFeeMsat,
+            hops: hops.length
+        };
+    }
+    static currentUtcDay() {
+        return new Date().toISOString().slice(0, 10);
+    }
+    loadRebalanceSpentMsat() {
+        const day = LightningNode.currentUtcDay();
+        if (!this.rebalanceBudgetDay || this.rebalanceBudgetDay.day !== day) {
+            let spent = 0n;
+            if (this.storage) {
+                try {
+                    const raw = this.storage.loadMetadata(LightningNode.REBALANCE_BUDGET_KEY);
+                    if (raw) {
+                        const parsed = JSON.parse(raw);
+                        if (parsed.day === day && parsed.spentFeeMsat) {
+                            spent = BigInt(parsed.spentFeeMsat);
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            this.rebalanceBudgetDay = { day, spentFeeMsat: spent };
+        }
+        return this.rebalanceBudgetDay.spentFeeMsat;
+    }
+    recordRebalanceSpend(feeMsat) {
+        const spent = this.loadRebalanceSpentMsat() + feeMsat;
+        this.rebalanceBudgetDay = {
+            day: LightningNode.currentUtcDay(),
+            spentFeeMsat: spent
+        };
+        this.safeStorage(() => this.storage.saveMetadata(LightningNode.REBALANCE_BUDGET_KEY, JSON.stringify({
+            day: this.rebalanceBudgetDay.day,
+            spentFeeMsat: spent.toString()
+        })), 'saveRebalanceBudget');
+    }
+    async executeRebalanceRecommendations(options) {
+        if (this.rebalanceRunInFlight) {
+            throw new Error('a rebalance execution run is already in progress');
+        }
+        this.rebalanceRunInFlight = true;
+        try {
+            const budgetSats = options?.budgetSatsPerDay ??
+                this.autoRebalanceConfig.budgetSatsPerDay ??
+                1000;
+            if (budgetSats < 0)
+                throw new Error('budgetSatsPerDay must be >= 0');
+            const budgetMsat = BigInt(budgetSats) * 1000n;
+            const plans = this.planRebalanceRecommendations(options?.minImbalancePct);
+            const attempts = [];
+            let feeSpentThisRunMsat = 0n;
+            for (const plan of plans) {
+                const remainingMsat = budgetMsat - this.loadRebalanceSpentMsat();
+                const proportionalCapMsat = (plan.amountSats * 1000n * 5000n) / 1000000n;
+                const perPairCapMsat = proportionalCapMsat > 1000n ? proportionalCapMsat : 1000n;
+                const feeCapMsat = remainingMsat < perPairCapMsat ? remainingMsat : perPairCapMsat;
+                if (feeCapMsat < 1000n) {
+                    attempts.push({
+                        fromChannelId: plan.fromChannelId,
+                        toChannelId: plan.toChannelId,
+                        amountSats: plan.amountSats,
+                        status: 'SKIPPED_BUDGET'
+                    });
+                    this.emitStructuredLog('payment', 'rebalance_budget_exhausted', {
+                        remainingMsat: remainingMsat.toString(),
+                        budgetMsat: budgetMsat.toString()
+                    });
+                    continue;
+                }
+                try {
+                    const result = await this.rebalanceChannel({
+                        fromChannelId: Buffer.from(plan.fromChannelId, 'hex'),
+                        toChannelId: Buffer.from(plan.toChannelId, 'hex'),
+                        amountSats: plan.amountSats,
+                        maxFeeSats: feeCapMsat / 1000n
+                    });
+                    this.recordRebalanceSpend(result.feeMsat);
+                    feeSpentThisRunMsat += result.feeMsat;
+                    attempts.push({
+                        fromChannelId: plan.fromChannelId,
+                        toChannelId: plan.toChannelId,
+                        amountSats: plan.amountSats,
+                        status: 'SUCCEEDED',
+                        feeMsat: result.feeMsat
+                    });
+                }
+                catch (err) {
+                    attempts.push({
+                        fromChannelId: plan.fromChannelId,
+                        toChannelId: plan.toChannelId,
+                        amountSats: plan.amountSats,
+                        status: 'FAILED',
+                        error: err instanceof Error ? err.message : String(err)
+                    });
+                }
+            }
+            const spent = this.loadRebalanceSpentMsat();
+            return {
+                attempts,
+                succeeded: attempts.filter((a) => a.status === 'SUCCEEDED').length,
+                failed: attempts.filter((a) => a.status === 'FAILED').length,
+                skippedBudget: attempts.filter((a) => a.status === 'SKIPPED_BUDGET')
+                    .length,
+                feeSpentMsat: feeSpentThisRunMsat,
+                budgetRemainingMsat: budgetMsat > spent ? budgetMsat - spent : 0n
+            };
+        }
+        finally {
+            this.rebalanceRunInFlight = false;
+        }
+    }
+    runFeeTuneOnce(now = Date.now()) {
+        const intervalMs = this.autoTuneFeesConfig.intervalMs ?? 21600000;
+        const floorPpm = this.autoTuneFeesConfig.floorPpm ?? fee_tuner_1.DEFAULT_FEE_TUNE_FLOOR_PPM;
+        const ceilPpm = this.autoTuneFeesConfig.ceilPpm ?? fee_tuner_1.DEFAULT_FEE_TUNE_CEIL_PPM;
+        if (floorPpm < 0 || ceilPpm < floorPpm) {
+            throw new Error('autoTuneFees requires 0 <= floorPpm <= ceilPpm');
+        }
+        const since = now - intervalMs;
+        const inputs = [];
+        for (const channel of this.channelManager.listChannels()) {
+            if (channel.getState() !== types_1.ChannelState.NORMAL)
+                continue;
+            const channelId = channel.getChannelId();
+            if (!channelId)
+                continue;
+            const hex = channelId.toString('hex');
+            const policy = this.getChannelPolicy(channelId);
+            if (!policy)
+                continue;
+            const st = channel.getFullState();
+            const capacityMsat = st.fundingSatoshis * 1000n;
+            if (capacityMsat <= 0n)
+                continue;
+            const forwards = this.listForwards({ since, until: now, channelId: hex });
+            inputs.push({
+                channelId: hex,
+                currentPpm: policy.feeProportionalMillionths,
+                localBalanceFraction: Number(st.localBalanceMsat) / Number(capacityMsat),
+                outboundForwards: forwards.filter((f) => f.outChannelId === hex).length,
+                totalForwards: forwards.length
+            });
+        }
+        const adjustments = (0, fee_tuner_1.computeFeeTuneAdjustments)(inputs, {
+            floorPpm,
+            ceilPpm
+        });
+        for (const adj of adjustments) {
+            this.setChannelPolicy(Buffer.from(adj.channelId, 'hex'), {
+                feeProportionalMillionths: adj.newPpm
+            });
+            this.emitStructuredLog('fee', 'auto_tune_adjusted', {
+                channelId: adj.channelId,
+                oldPpm: adj.oldPpm,
+                newPpm: adj.newPpm,
+                reason: adj.reason,
+                windowMs: intervalMs
+            });
+        }
+        return adjustments;
+    }
     getFeeSnapshot() {
         return this.feeAdvisor.getSnapshot();
     }
@@ -1717,6 +2839,14 @@ class LightningNode extends events_1.EventEmitter {
         info.localReserveMsat = state.remoteConfig.channelReserveSatoshis * 1000n;
         info.remoteReserveMsat = state.localConfig.channelReserveSatoshis * 1000n;
         info.isPrivate = !state.announceChannel;
+        const policy = this.getChannelPolicy(channelId);
+        if (policy) {
+            info.feeBaseMsat = policy.feeBaseMsat;
+            info.feeProportionalMillionths = policy.feeProportionalMillionths;
+            info.cltvExpiryDelta = policy.cltvExpiryDelta;
+            info.htlcMinimumMsat = policy.htlcMinimumMsat;
+            info.htlcMaximumMsat = policy.htlcMaximumMsat;
+        }
         return info;
     }
     registerChannelScid(channelId, scid) {
@@ -1744,9 +2874,13 @@ class LightningNode extends events_1.EventEmitter {
             if (this.alias) {
                 Buffer.from(this.alias, 'utf8').copy(aliasBuffer, 0, 0, Math.min(32, Buffer.byteLength(this.alias, 'utf8')));
             }
+            const announcedFeatures = flags_1.FeatureFlags.empty();
+            if (this.largeChannels) {
+                announcedFeatures.setOptional(flags_1.Feature.LARGE_CHANNELS);
+            }
             const payload = encodeNodeAnnouncementMessage({
                 signature: Buffer.alloc(64),
-                features: Buffer.alloc(0),
+                features: announcedFeatures.toBuffer(),
                 timestamp,
                 nodeId,
                 rgbColor: Buffer.from([0, 0, 0]),
@@ -1761,11 +2895,24 @@ class LightningNode extends events_1.EventEmitter {
             return null;
         }
     }
-    refreshChannelUpdate(cachedUpdate, timestamp) {
+    refreshChannelUpdate(cachedUpdate, timestamp, channelId) {
         try {
             const { encodeChannelUpdateMessage } = require('../gossip/messages');
             const msg = (0, messages_1.decodeChannelUpdateMessage)(cachedUpdate);
             msg.timestamp = timestamp;
+            const policy = channelId ? this.getChannelPolicy(channelId) : null;
+            if (policy && channelId) {
+                msg.cltvExpiryDelta = policy.cltvExpiryDelta;
+                msg.feeBaseMsat = policy.feeBaseMsat;
+                msg.feeProportionalMillionths = policy.feeProportionalMillionths;
+                msg.htlcMinimumMsat = policy.htlcMinimumMsat;
+                const capacityMsat = this.channelManager.getChannel(channelId).getFullState()
+                    .fundingSatoshis * 1000n;
+                msg.htlcMaximumMsat =
+                    policy.htlcMaximumMsat > capacityMsat
+                        ? capacityMsat
+                        : policy.htlcMaximumMsat;
+            }
             const payload = encodeChannelUpdateMessage(msg);
             const sig = (0, validation_1.signChannelUpdate)(payload, this.nodePrivkey);
             sig.copy(payload, 0);
@@ -1780,11 +2927,11 @@ class LightningNode extends events_1.EventEmitter {
             return;
         try {
             for (const { announcement, update } of this._ownChannelGossip.values()) {
-                this.peerManager.sendToPeer(pubkey, types_4.MessageType.CHANNEL_ANNOUNCEMENT, announcement);
-                this.peerManager.sendToPeer(pubkey, types_4.MessageType.CHANNEL_UPDATE, update);
+                this.peerManager.sendToPeer(pubkey, types_5.MessageType.CHANNEL_ANNOUNCEMENT, announcement);
+                this.peerManager.sendToPeer(pubkey, types_5.MessageType.CHANNEL_UPDATE, update);
             }
             if (this._ownNodeAnnouncement) {
-                this.peerManager.sendToPeer(pubkey, types_4.MessageType.NODE_ANNOUNCEMENT, this._ownNodeAnnouncement);
+                this.peerManager.sendToPeer(pubkey, types_5.MessageType.NODE_ANNOUNCEMENT, this._ownNodeAnnouncement);
             }
         }
         catch {
@@ -1807,7 +2954,7 @@ class LightningNode extends events_1.EventEmitter {
                 this._ownNodeAnnouncement = refreshed;
             }
             for (const [channelIdHex, gossip] of this._ownChannelGossip) {
-                const refreshedUpdate = this.refreshChannelUpdate(gossip.update, now);
+                const refreshedUpdate = this.refreshChannelUpdate(gossip.update, now, Buffer.from(channelIdHex, 'hex'));
                 if (refreshedUpdate) {
                     this._ownChannelGossip.set(channelIdHex, {
                         announcement: gossip.announcement,
@@ -1822,56 +2969,59 @@ class LightningNode extends events_1.EventEmitter {
     }
     getPrivateChannelRoutingHints() {
         const hints = [];
-        const channels = this.channelManager.listChannels();
-        for (const channel of channels) {
-            const state = channel.getFullState();
-            const effectiveState = state.preReestablishState ?? channel.getState();
-            if (effectiveState !== types_1.ChannelState.NORMAL)
-                continue;
-            const channelId = channel.getChannelId();
-            if (!channelId)
-                continue;
-            const peerPubkeyHex = this.channelManager.getPeerForChannel(channelId);
-            if (!peerPubkeyHex)
-                continue;
-            const scid = state.shortChannelId || state.scidAlias;
-            if (!scid)
-                continue;
-            const peerPubkey = Buffer.from(peerPubkeyHex, 'hex');
-            let feeBaseMsat = this.forwardingFeeBaseMsat;
-            let feeProportionalMillionths = this.forwardingFeePropMillionths;
-            let cltvExpiryDelta = this.forwardingCltvDelta;
-            const directPolicy = state.remoteForwardingPolicy;
-            if (directPolicy) {
-                feeBaseMsat = directPolicy.feeBaseMsat;
-                feeProportionalMillionths = directPolicy.feeProportionalMillionths;
-                cltvExpiryDelta = directPolicy.cltvExpiryDelta;
-            }
-            if (state.shortChannelId) {
-                const graphChannel = this.graph.getChannel(state.shortChannelId);
-                const peerUpdate = graphChannel?.nodeId1.equals(peerPubkey)
-                    ? graphChannel.update1
-                    : graphChannel?.nodeId2.equals(peerPubkey)
-                        ? graphChannel.update2
-                        : undefined;
-                if (peerUpdate &&
-                    (!directPolicy || peerUpdate.timestamp >= directPolicy.timestamp)) {
-                    feeBaseMsat = peerUpdate.feeBaseMsat;
-                    feeProportionalMillionths = peerUpdate.feeProportionalMillionths;
-                    cltvExpiryDelta = peerUpdate.cltvExpiryDelta;
-                }
-            }
-            const hop = {
-                pubkey: peerPubkey,
-                shortChannelId: scid,
-                feeBaseMsat,
-                feeProportionalMillionths,
-                cltvExpiryDelta
-            };
-            hints.push([hop]);
+        for (const channel of this.channelManager.listChannels()) {
+            const hop = this.buildRoutingHintForChannel(channel);
+            if (hop)
+                hints.push([hop]);
         }
         return hints;
     }
+    buildRoutingHintForChannel(channel) {
+        const state = channel.getFullState();
+        const effectiveState = state.preReestablishState ?? channel.getState();
+        if (effectiveState !== types_1.ChannelState.NORMAL)
+            return null;
+        const channelId = channel.getChannelId();
+        if (!channelId)
+            return null;
+        const peerPubkeyHex = this.channelManager.getPeerForChannel(channelId);
+        if (!peerPubkeyHex)
+            return null;
+        const scid = state.shortChannelId || state.scidAlias;
+        if (!scid)
+            return null;
+        const peerPubkey = Buffer.from(peerPubkeyHex, 'hex');
+        let feeBaseMsat = this.forwardingFeeBaseMsat;
+        let feeProportionalMillionths = this.forwardingFeePropMillionths;
+        let cltvExpiryDelta = this.forwardingCltvDelta;
+        const directPolicy = state.remoteForwardingPolicy;
+        if (directPolicy) {
+            feeBaseMsat = directPolicy.feeBaseMsat;
+            feeProportionalMillionths = directPolicy.feeProportionalMillionths;
+            cltvExpiryDelta = directPolicy.cltvExpiryDelta;
+        }
+        if (state.shortChannelId) {
+            const graphChannel = this.graph.getChannel(state.shortChannelId);
+            const peerUpdate = graphChannel?.nodeId1.equals(peerPubkey)
+                ? graphChannel.update1
+                : graphChannel?.nodeId2.equals(peerPubkey)
+                    ? graphChannel.update2
+                    : undefined;
+            if (peerUpdate &&
+                (!directPolicy || peerUpdate.timestamp >= directPolicy.timestamp)) {
+                feeBaseMsat = peerUpdate.feeBaseMsat;
+                feeProportionalMillionths = peerUpdate.feeProportionalMillionths;
+                cltvExpiryDelta = peerUpdate.cltvExpiryDelta;
+            }
+        }
+        return {
+            pubkey: peerPubkey,
+            shortChannelId: scid,
+            feeBaseMsat,
+            feeProportionalMillionths,
+            cltvExpiryDelta
+        };
+    }
     findBlindedIntroExtension(peerPubkey) {
         const ourNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
         for (const edge of this.graph.getNodeChannels(peerPubkey)) {
@@ -2006,16 +3156,16 @@ class LightningNode extends events_1.EventEmitter {
     }
     handleGossipMessage(pubkey, type, payload) {
         switch (type) {
-            case types_4.MessageType.CHANNEL_ANNOUNCEMENT:
+            case types_5.MessageType.CHANNEL_ANNOUNCEMENT:
                 this.handleChannelAnnouncement(payload);
                 break;
-            case types_4.MessageType.NODE_ANNOUNCEMENT:
+            case types_5.MessageType.NODE_ANNOUNCEMENT:
                 this.handleNodeAnnouncement(payload);
                 break;
-            case types_4.MessageType.CHANNEL_UPDATE:
+            case types_5.MessageType.CHANNEL_UPDATE:
                 this.handleChannelUpdate(payload);
                 break;
-            case types_4.MessageType.REPLY_CHANNEL_RANGE: {
+            case types_5.MessageType.REPLY_CHANNEL_RANGE: {
                 const syncMgr = this.gossipSyncManagers.get(pubkey);
                 if (syncMgr) {
                     const msg = (0, gossip_queries_1.decodeReplyChannelRangeMessage)(payload);
@@ -2026,7 +3176,7 @@ class LightningNode extends events_1.EventEmitter {
                 }
                 break;
             }
-            case types_4.MessageType.REPLY_SHORT_CHANNEL_IDS_END: {
+            case types_5.MessageType.REPLY_SHORT_CHANNEL_IDS_END: {
                 const syncMgr = this.gossipSyncManagers.get(pubkey);
                 if (syncMgr) {
                     const msg = (0, gossip_queries_1.decodeReplyShortChannelIdsEndMessage)(payload);
@@ -2037,7 +3187,7 @@ class LightningNode extends events_1.EventEmitter {
                 }
                 break;
             }
-            case types_4.MessageType.QUERY_CHANNEL_RANGE: {
+            case types_5.MessageType.QUERY_CHANNEL_RANGE: {
                 const syncMgr = this.getOrCreateSyncManager(pubkey);
                 const msg = (0, gossip_queries_1.decodeQueryChannelRangeMessage)(payload);
                 const responses = syncMgr.handleQueryChannelRange(msg);
@@ -2046,7 +3196,7 @@ class LightningNode extends events_1.EventEmitter {
                 }
                 break;
             }
-            case types_4.MessageType.QUERY_SHORT_CHANNEL_IDS: {
+            case types_5.MessageType.QUERY_SHORT_CHANNEL_IDS: {
                 const syncMgr = this.getOrCreateSyncManager(pubkey);
                 const msg = (0, gossip_queries_1.decodeQueryShortChannelIdsMessage)(payload);
                 const responses = syncMgr.handleQueryShortChannelIds(msg);
@@ -2055,7 +3205,7 @@ class LightningNode extends events_1.EventEmitter {
                 }
                 break;
             }
-            case types_4.MessageType.GOSSIP_TIMESTAMP_FILTER:
+            case types_5.MessageType.GOSSIP_TIMESTAMP_FILTER:
                 (0, gossip_queries_1.decodeGossipTimestampFilterMessage)(payload);
                 this.sendOwnGossipTo(pubkey);
                 break;
@@ -2237,8 +3387,8 @@ class LightningNode extends events_1.EventEmitter {
             descriptionHash: options.descriptionHash,
             paymentHash,
             paymentSecret,
-            expiry: options.expiry ?? types_3.DEFAULT_EXPIRY,
-            minFinalCltvExpiry: options.minFinalCltvExpiry ?? types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY,
+            expiry: options.expiry ?? types_4.DEFAULT_EXPIRY,
+            minFinalCltvExpiry: options.minFinalCltvExpiry ?? types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY,
             privateKey: this.nodePrivkey,
             payeeNodeKey: (0, ecdh_1.getPublicKey)(this.nodePrivkey),
             routingHints: !useBlinded && routingHints.length > 0 ? routingHints : undefined,
@@ -2249,8 +3399,8 @@ class LightningNode extends events_1.EventEmitter {
             paymentHash,
             preimage,
             amountMsat: options.amountMsat || 0n,
-            status: types_5.PaymentStatus.PENDING,
-            direction: types_5.PaymentDirection.INCOMING,
+            status: types_6.PaymentStatus.PENDING,
+            direction: types_6.PaymentDirection.INCOMING,
             createdAt: Date.now()
         };
         this.payments.set(paymentHash.toString('hex'), payment);
@@ -2265,7 +3415,7 @@ class LightningNode extends events_1.EventEmitter {
                 bolt11: invoiceStr,
                 amountMsat: options.amountMsat,
                 description: options.description,
-                expiry: options.expiry ?? types_3.DEFAULT_EXPIRY,
+                expiry: options.expiry ?? types_4.DEFAULT_EXPIRY,
                 createdAt: createdAtSecs,
                 hold: options.hold
             });
@@ -2276,7 +3426,7 @@ class LightningNode extends events_1.EventEmitter {
             bolt11: invoiceStr,
             amountMsat: options.amountMsat,
             description: options.description,
-            expiry: options.expiry ?? types_3.DEFAULT_EXPIRY,
+            expiry: options.expiry ?? types_4.DEFAULT_EXPIRY,
             createdAt: createdAtSecs,
             hold: options.hold
         });
@@ -2311,27 +3461,27 @@ class LightningNode extends events_1.EventEmitter {
         const invoice = (0, decode_1.decode)(invoiceStr);
         const dedupHashHex = invoice.paymentHash.toString('hex');
         const existingPayment = this.payments.get(dedupHashHex);
-        if (existingPayment && existingPayment.status === types_5.PaymentStatus.PENDING) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.DUPLICATE_PAYMENT, 'Payment already in flight for this invoice');
+        if (existingPayment && existingPayment.status === types_6.PaymentStatus.PENDING) {
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.DUPLICATE_PAYMENT, 'Payment already in flight for this invoice');
         }
         const destination = invoice.payeeNodeKey || invoice.recoveredPubkey;
         if (!destination) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.INVALID_INVOICE, 'Cannot determine payee from invoice');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.INVALID_INVOICE, 'Cannot determine payee from invoice');
         }
         let paymentAmountMsat = invoice.amountMsat;
         if (paymentAmountMsat === undefined) {
             if (amountMsat === undefined) {
-                throw new types_5.LightningPaymentError(types_5.LightningErrorCode.MISSING_AMOUNT, 'Invoice has no amount and no amountMsat provided');
+                throw new types_6.LightningPaymentError(types_6.LightningErrorCode.MISSING_AMOUNT, 'Invoice has no amount and no amountMsat provided');
             }
             paymentAmountMsat = amountMsat;
         }
-        const expiryTimestamp = invoice.timestamp + (invoice.expiry ?? types_3.DEFAULT_EXPIRY);
+        const expiryTimestamp = invoice.timestamp + (invoice.expiry ?? types_4.DEFAULT_EXPIRY);
         if (Math.floor(Date.now() / 1000) > expiryTimestamp) {
             const payment = {
                 paymentHash: invoice.paymentHash,
                 amountMsat: paymentAmountMsat,
-                status: types_5.PaymentStatus.FAILED,
-                direction: types_5.PaymentDirection.OUTGOING,
+                status: types_6.PaymentStatus.FAILED,
+                direction: types_6.PaymentDirection.OUTGOING,
                 createdAt: Date.now(),
                 completedAt: Date.now()
             };
@@ -2339,16 +3489,16 @@ class LightningNode extends events_1.EventEmitter {
             this.emit('payment:failed', payment);
             return payment;
         }
-        const finalCltvExpiry = invoice.minFinalCltvExpiry ?? types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
+        const finalCltvExpiry = invoice.minFinalCltvExpiry ?? types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
         const sourceNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
         if (invoice.blindedPaths && invoice.blindedPaths.length > 0) {
             const blinded = invoice.blindedPaths[0];
             const blindedRoute = (0, pathfinding_1.findRouteToBlindedPath)(this.graph, sourceNodeId, blinded.path, blinded.payInfo, paymentAmountMsat, finalCltvExpiry, undefined, excludedChannels, this.missionControl, this.getLocalChannelEdges());
             if (!blindedRoute) {
-                throw new types_5.LightningPaymentError(types_5.LightningErrorCode.NO_ROUTE, 'No route to blinded path introduction node');
+                throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_ROUTE, 'No route to blinded path introduction node');
             }
             if (maxFeeMsat !== undefined && blindedRoute.totalFeeMsat > maxFeeMsat) {
-                throw new types_5.LightningPaymentError(types_5.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
+                throw new types_6.LightningPaymentError(types_6.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
             }
             const bHashHex = invoice.paymentHash.toString('hex');
             if (!this.paymentRetryContexts.has(bHashHex)) {
@@ -2369,16 +3519,16 @@ class LightningNode extends events_1.EventEmitter {
             const multiRoute = (0, pathfinding_1.findMultiPathRoute)(this.graph, sourceNodeId, destination, paymentAmountMsat, finalCltvExpiry, undefined, undefined, this.missionControl, invoice.routingHints, undefined, localChannels);
             if (multiRoute) {
                 if (maxFeeMsat !== undefined && multiRoute.totalFeeMsat > maxFeeMsat) {
-                    throw new types_5.LightningPaymentError(types_5.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
+                    throw new types_6.LightningPaymentError(types_6.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
                 }
                 return this.sendPaymentMpp(invoiceStr, invoice, multiRoute, finalCltvExpiry);
             }
         }
         if (!route) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.NO_ROUTE, 'No route found to destination');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_ROUTE, 'No route found to destination');
         }
         if (maxFeeMsat !== undefined && route.totalFeeMsat > maxFeeMsat) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
         }
         const hashHex = invoice.paymentHash.toString('hex');
         if (!this.paymentRetryContexts.has(hashHex)) {
@@ -2433,9 +3583,10 @@ class LightningNode extends events_1.EventEmitter {
         const onionPacket = (0, construct_1.constructOnionPacket)(sessionKey, onionHops, paymentHash);
         const onionBuf = (0, construct_1.encodeOnionPacket)(onionPacket);
         const firstHopPubkey = hops[0].pubkey.toString('hex');
-        const outChannel = this.findChannelForPeer(firstHopPubkey, hops[0].amountToForwardMsat);
+        const outChannel = this.findLocalChannelByScid(hops[0].shortChannelId, firstHopPubkey) ??
+            this.findChannelForPeer(firstHopPubkey, hops[0].amountToForwardMsat);
         if (!outChannel) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.NO_CHANNEL_TO_HOP, `No channel to first hop ${firstHopPubkey}`);
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_CHANNEL_TO_HOP, `No channel to first hop ${firstHopPubkey}`);
         }
         const channelId = outChannel.getChannelId();
         const cltvExpiry = hops[0].outgoingCltvValue + baseHeight;
@@ -2443,8 +3594,8 @@ class LightningNode extends events_1.EventEmitter {
         const payment = {
             paymentHash,
             amountMsat: amount,
-            status: types_5.PaymentStatus.PENDING,
-            direction: types_5.PaymentDirection.OUTGOING,
+            status: types_6.PaymentStatus.PENDING,
+            direction: types_6.PaymentDirection.OUTGOING,
             route: route,
             sharedSecrets,
             createdAt: Date.now()
@@ -2461,7 +3612,7 @@ class LightningNode extends events_1.EventEmitter {
         }
         const result = this.channelManager.addHtlc(channelId, amount, paymentHash, cltvExpiry, onionBuf);
         if (!result.ok) {
-            payment.status = types_5.PaymentStatus.FAILED;
+            payment.status = types_6.PaymentStatus.FAILED;
             payment.completedAt = Date.now();
             this.emit('payment:failed', payment);
         }
@@ -2470,31 +3621,31 @@ class LightningNode extends events_1.EventEmitter {
     sendKeysend(options) {
         const { destination, amountMsat, maxFeeMsat, customRecords: extraRecords, metadata } = options;
         if (!destination || destination.length !== 33) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.INVALID_KEYSEND, 'destination must be a 33-byte compressed public key');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.INVALID_KEYSEND, 'destination must be a 33-byte compressed public key');
         }
         if (amountMsat <= 0n) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.INVALID_KEYSEND, 'amountMsat must be positive');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.INVALID_KEYSEND, 'amountMsat must be positive');
         }
         const preimage = crypto_1.default.randomBytes(32);
         const paymentHash = crypto_1.default.createHash('sha256').update(preimage).digest();
         const hashHex = paymentHash.toString('hex');
         const existingPayment = this.payments.get(hashHex);
-        if (existingPayment && existingPayment.status === types_5.PaymentStatus.PENDING) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.DUPLICATE_PAYMENT, 'Payment already in flight');
+        if (existingPayment && existingPayment.status === types_6.PaymentStatus.PENDING) {
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.DUPLICATE_PAYMENT, 'Payment already in flight');
         }
-        const finalCltvExpiry = types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
+        const finalCltvExpiry = types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
         const sourceNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
         const route = (0, pathfinding_1.findRoute)(this.graph, sourceNodeId, destination, amountMsat, finalCltvExpiry, undefined, undefined, this.missionControl, undefined, undefined, undefined, this.getLocalChannelEdges());
         if (!route) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.NO_ROUTE, 'No route found to destination');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_ROUTE, 'No route found to destination');
         }
         if (maxFeeMsat !== undefined && route.totalFeeMsat > maxFeeMsat) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.FEE_EXCEEDS_MAX, 'Route fee exceeds maximum');
         }
         const hops = route.hops;
         const baseHeight = this.currentBlockHeight;
         const keysendRecords = new Map();
-        keysendRecords.set(types_2.KEYSEND_TLV_TYPE, preimage);
+        keysendRecords.set(types_3.KEYSEND_TLV_TYPE, preimage);
         if (extraRecords) {
             for (const [type, value] of extraRecords) {
                 keysendRecords.set(type, value);
@@ -2523,7 +3674,7 @@ class LightningNode extends events_1.EventEmitter {
         const firstHopPubkey = hops[0].pubkey.toString('hex');
         const outChannel = this.findChannelForPeer(firstHopPubkey, hops[0].amountToForwardMsat);
         if (!outChannel) {
-            throw new types_5.LightningPaymentError(types_5.LightningErrorCode.NO_CHANNEL_TO_HOP, `No channel to first hop ${firstHopPubkey}`);
+            throw new types_6.LightningPaymentError(types_6.LightningErrorCode.NO_CHANNEL_TO_HOP, `No channel to first hop ${firstHopPubkey}`);
         }
         const channelId = outChannel.getChannelId();
         const cltvExpiry = hops[0].outgoingCltvValue + baseHeight;
@@ -2532,8 +3683,8 @@ class LightningNode extends events_1.EventEmitter {
             paymentHash,
             preimage,
             amountMsat: amount,
-            status: types_5.PaymentStatus.PENDING,
-            direction: types_5.PaymentDirection.OUTGOING,
+            status: types_6.PaymentStatus.PENDING,
+            direction: types_6.PaymentDirection.OUTGOING,
             route: route,
             sharedSecrets,
             createdAt: Date.now(),
@@ -2551,7 +3702,7 @@ class LightningNode extends events_1.EventEmitter {
         }
         const result = this.channelManager.addHtlc(channelId, amount, paymentHash, cltvExpiry, onionBuf);
         if (!result.ok) {
-            payment.status = types_5.PaymentStatus.FAILED;
+            payment.status = types_6.PaymentStatus.FAILED;
             payment.completedAt = Date.now();
             this.emit('payment:failed', payment);
         }
@@ -2564,8 +3715,8 @@ class LightningNode extends events_1.EventEmitter {
         const payment = {
             paymentHash,
             amountMsat: totalMsat,
-            status: types_5.PaymentStatus.PENDING,
-            direction: types_5.PaymentDirection.OUTGOING,
+            status: types_6.PaymentStatus.PENDING,
+            direction: types_6.PaymentDirection.OUTGOING,
             createdAt: Date.now()
         };
         this.payments.set(hashHex, payment);
@@ -2632,16 +3783,16 @@ class LightningNode extends events_1.EventEmitter {
                 channelId,
                 htlcId,
                 amountMsat: amount,
-                status: types_5.PaymentStatus.PENDING
+                status: types_6.PaymentStatus.PENDING
             });
             const result = this.channelManager.addHtlc(channelId, amount, paymentHash, cltvExpiry, onionBuf);
             if (!result.ok) {
                 for (const dispatched of mppState.parts) {
-                    if (dispatched.status === types_5.PaymentStatus.PENDING) {
-                        this.channelManager.failHtlc(dispatched.channelId, dispatched.htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_2.TEMPORARY_CHANNEL_FAILURE));
+                    if (dispatched.status === types_6.PaymentStatus.PENDING) {
+                        this.channelManager.failHtlc(dispatched.channelId, dispatched.htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_3.TEMPORARY_CHANNEL_FAILURE));
                     }
                 }
-                payment.status = types_5.PaymentStatus.FAILED;
+                payment.status = types_6.PaymentStatus.FAILED;
                 payment.completedAt = Date.now();
                 this.outboundMppPayments.delete(hashHex);
                 this.emit('payment:failed', payment);
@@ -2661,12 +3812,12 @@ class LightningNode extends events_1.EventEmitter {
         if (!channel)
             return;
         if (this.getTotalInFlightHtlcCount() > this.maxTotalInFlightHtlcs) {
-            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_2.TEMPORARY_NODE_FAILURE));
+            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_3.TEMPORARY_NODE_FAILURE));
             return;
         }
         const peerPubkey = this.channelManager.getPeerForChannel(channelId);
         if (peerPubkey && !this.rateLimiter.tryConsume(peerPubkey)) {
-            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_2.TEMPORARY_NODE_FAILURE));
+            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_3.TEMPORARY_NODE_FAILURE));
             return;
         }
         const htlcEntry = channel.getFullState().htlcs.get(`received-${htlcId}`);
@@ -2689,7 +3840,7 @@ class LightningNode extends events_1.EventEmitter {
                 message: `Onion processing failed for HTLC ${htlcId} on channel ${channelId.toString('hex')}: ${err.message || 'unknown'}`,
                 timestamp: Date.now()
             });
-            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_2.INVALID_ONION_HMAC));
+            this.channelManager.failHtlc(channelId, htlcId, (0, failures_1.createFailureMessage)(Buffer.alloc(32), types_3.INVALID_ONION_HMAC));
             return;
         }
         const htlcSecretKey = `${channelId.toString('hex')}:${htlcId}`;
@@ -2712,11 +3863,11 @@ class LightningNode extends events_1.EventEmitter {
         const hashHex = paymentHash.toString('hex');
         const htlcSecretKey = `${channelId.toString('hex')}:${htlcId}`;
         const sharedSecret = this.receivedHtlcSharedSecrets.get(htlcSecretKey);
-        const keysendPreimage = hopPayload?.customRecords?.get(types_2.KEYSEND_TLV_TYPE);
+        const keysendPreimage = hopPayload?.customRecords?.get(types_3.KEYSEND_TLV_TYPE);
         if (keysendPreimage) {
             if (keysendPreimage.length !== 32) {
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2728,7 +3879,7 @@ class LightningNode extends events_1.EventEmitter {
                 .digest();
             if (!expectedHash.equals(paymentHash)) {
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2739,8 +3890,8 @@ class LightningNode extends events_1.EventEmitter {
                 paymentHash,
                 preimage: keysendPreimage,
                 amountMsat,
-                status: types_5.PaymentStatus.PENDING,
-                direction: types_5.PaymentDirection.INCOMING,
+                status: types_6.PaymentStatus.PENDING,
+                direction: types_6.PaymentDirection.INCOMING,
                 createdAt: Date.now(),
                 metadata: { _keysend: 'true' }
             };
@@ -2765,7 +3916,7 @@ class LightningNode extends events_1.EventEmitter {
                 paymentHash: hashHex
             });
             const reason = sharedSecret
-                ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                 : Buffer.alloc(290);
             this.cleanupHtlcSharedSecret(htlcSecretKey);
             this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2779,7 +3930,7 @@ class LightningNode extends events_1.EventEmitter {
                     paymentHash: hashHex
                 });
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2795,7 +3946,7 @@ class LightningNode extends events_1.EventEmitter {
                     onionCltv: hopPayload.outgoingCltvValue
                 });
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.FINAL_INCORRECT_CLTV_EXPIRY)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.FINAL_INCORRECT_CLTV_EXPIRY)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2803,14 +3954,14 @@ class LightningNode extends events_1.EventEmitter {
             }
             if (this.currentBlockHeight > 0 &&
                 incomingCltvExpiry <
-                    this.currentBlockHeight + types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY) {
+                    this.currentBlockHeight + types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY) {
                 this.emitStructuredLog('htlc', 'final_expiry_too_soon', {
                     paymentHash: hashHex,
                     htlcCltv: incomingCltvExpiry,
                     height: this.currentBlockHeight
                 });
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2831,7 +3982,7 @@ class LightningNode extends events_1.EventEmitter {
                     invoiced: finalInvoice.amountMsat.toString()
                 });
                 const reason = sharedSecret
-                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
+                    ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS)
                     : Buffer.alloc(290);
                 this.cleanupHtlcSharedSecret(htlcSecretKey);
                 this.channelManager.failHtlc(channelId, htlcId, reason);
@@ -2891,11 +4042,12 @@ class LightningNode extends events_1.EventEmitter {
         this.persistHeldHtlcs();
         const payment = this.payments.get(hashHex);
         if (payment) {
-            payment.status = types_5.PaymentStatus.COMPLETED;
+            payment.status = types_6.PaymentStatus.COMPLETED;
             payment.preimage = pre;
             payment.completedAt = Date.now();
             this.safeStorage(() => this.persistPayment(paymentHash), 'persistPayment');
             this.emit('payment:received', payment);
+            this.emitInvoiceSettled(paymentHash, payment);
         }
         this.emitStructuredLog('payment', 'received', {
             paymentHash: hashHex,
@@ -2903,7 +4055,21 @@ class LightningNode extends events_1.EventEmitter {
         });
         return true;
     }
-    cancelHeldHtlc(paymentHash, failureCode = types_2.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS) {
+    emitInvoiceSettled(paymentHash, payment) {
+        const invoice = this.invoices.get(paymentHash.toString('hex'));
+        if (!invoice)
+            return;
+        this.emit('invoice:settled', {
+            paymentHash,
+            bolt11: invoice.bolt11,
+            amountMsat: payment.amountMsat
+        });
+        this.emitStructuredLog('payment', 'invoice_settled', {
+            paymentHash: paymentHash.toString('hex'),
+            amountMsat: payment.amountMsat.toString()
+        });
+    }
+    cancelHeldHtlc(paymentHash, failureCode = types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS) {
         const hashHex = paymentHash.toString('hex');
         const held = this.heldHtlcs.get(hashHex);
         if (!held || held.length === 0)
@@ -2920,9 +4086,80 @@ class LightningNode extends events_1.EventEmitter {
         this.heldHtlcs.delete(hashHex);
         this.heldInvoiceHashes.delete(hashHex);
         this.persistHeldHtlcs();
+        this.markHoldInvoiceCancelled(hashHex);
         this.emitStructuredLog('htlc', 'held_cancelled', { paymentHash: hashHex });
         return true;
     }
+    markHoldInvoiceCancelled(hashHex) {
+        this.preimages.delete(hashHex);
+        this.paymentSecrets.delete(hashHex);
+        this.safeStorage(() => this.storage.deletePaymentSecret(hashHex), 'deletePaymentSecret');
+        const invoice = this.invoices.get(hashHex);
+        if (invoice && !invoice.cancelledAt) {
+            invoice.cancelledAt = Date.now();
+            this.safeStorage(() => this.storage.saveInvoice(hashHex, invoice), 'saveInvoice');
+        }
+        const payment = this.payments.get(hashHex);
+        if (payment &&
+            payment.direction === types_6.PaymentDirection.INCOMING &&
+            payment.status !== types_6.PaymentStatus.COMPLETED) {
+            payment.status = types_6.PaymentStatus.FAILED;
+            this.safeStorage(() => this.persistPayment(Buffer.from(hashHex, 'hex')), 'persistPayment');
+        }
+    }
+    cancelHoldInvoice(paymentHash) {
+        const hashHex = paymentHash.toString('hex');
+        const held = this.heldHtlcs.get(hashHex);
+        if (held && held.length > 0) {
+            const count = held.length;
+            this.cancelHeldHtlc(paymentHash);
+            return { htlcsFailed: count };
+        }
+        if (!this.heldInvoiceHashes.has(hashHex))
+            return null;
+        this.heldInvoiceHashes.delete(hashHex);
+        this.markHoldInvoiceCancelled(hashHex);
+        this.emitStructuredLog('htlc', 'held_cancelled', { paymentHash: hashHex });
+        return { htlcsFailed: 0 };
+    }
+    listHoldInvoices() {
+        const out = [];
+        for (const [hashHex, invoice] of this.invoices) {
+            if (!invoice.hold)
+                continue;
+            const held = this.heldHtlcs.get(hashHex) ?? [];
+            let heldAmountMsat = 0n;
+            for (const h of held)
+                heldAmountMsat += h.amountMsat;
+            const payment = this.payments.get(hashHex);
+            let state;
+            if (held.length > 0) {
+                state = 'ACCEPTED';
+            }
+            else if (payment?.status === types_6.PaymentStatus.COMPLETED &&
+                payment.direction === types_6.PaymentDirection.INCOMING) {
+                state = 'SETTLED';
+            }
+            else if (invoice.cancelledAt || !this.heldInvoiceHashes.has(hashHex)) {
+                state = 'CANCELLED';
+            }
+            else {
+                state = 'OPEN';
+            }
+            out.push({
+                paymentHash: hashHex,
+                bolt11: invoice.bolt11,
+                amountMsat: invoice.amountMsat,
+                description: invoice.description,
+                expiry: invoice.expiry,
+                createdAt: invoice.createdAt,
+                state,
+                heldAmountMsat,
+                htlcCount: held.length
+            });
+        }
+        return out;
+    }
     scanExpiringHeldHtlcs(height) {
         if (height <= 0)
             return;
@@ -3006,7 +4243,7 @@ class LightningNode extends events_1.EventEmitter {
             channelId,
             htlcId,
             amountMsat,
-            status: types_5.PaymentStatus.PENDING
+            status: types_6.PaymentStatus.PENDING
         };
         pending.receivedParts.push(part);
         let totalReceived = 0n;
@@ -3016,16 +4253,17 @@ class LightningNode extends events_1.EventEmitter {
         if (totalReceived >= pending.totalMsat) {
             this.channelManager.recordPreimage(paymentHash, preimage);
             for (const p of pending.receivedParts) {
-                p.status = types_5.PaymentStatus.COMPLETED;
+                p.status = types_6.PaymentStatus.COMPLETED;
                 this.channelManager.fulfillHtlc(p.channelId, p.htlcId, preimage);
             }
             this.pendingMppPayments.delete(hashHex);
             const payment = this.payments.get(hashHex);
             if (payment) {
-                payment.status = types_5.PaymentStatus.COMPLETED;
+                payment.status = types_6.PaymentStatus.COMPLETED;
                 payment.completedAt = Date.now();
                 this.persistPayment(paymentHash);
                 this.emit('payment:received', payment);
+                this.emitInvoiceSettled(paymentHash, payment);
             }
         }
     }
@@ -3034,12 +4272,12 @@ class LightningNode extends events_1.EventEmitter {
         for (const [hashHex, pending] of this.pendingMppPayments) {
             if (now - pending.createdAt > this.mppTimeoutMs) {
                 for (const part of pending.receivedParts) {
-                    if (part.status === types_5.PaymentStatus.PENDING) {
-                        part.status = types_5.PaymentStatus.FAILED;
+                    if (part.status === types_6.PaymentStatus.PENDING) {
+                        part.status = types_6.PaymentStatus.FAILED;
                         const htlcSecretKey = `${part.channelId.toString('hex')}:${part.htlcId}`;
                         const sharedSecret = this.receivedHtlcSharedSecrets.get(htlcSecretKey);
                         const reason = sharedSecret
-                            ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.MPP_TIMEOUT)
+                            ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.MPP_TIMEOUT)
                             : Buffer.alloc(290);
                         this.cleanupHtlcSharedSecret(htlcSecretKey);
                         this.channelManager.failHtlc(part.channelId, part.htlcId, reason);
@@ -3056,7 +4294,7 @@ class LightningNode extends events_1.EventEmitter {
         this.paymentSecrets.delete(hashHex);
         const payment = this.payments.get(hashHex);
         if (payment) {
-            payment.status = types_5.PaymentStatus.COMPLETED;
+            payment.status = types_6.PaymentStatus.COMPLETED;
             payment.completedAt = Date.now();
         }
         if (this.storage) {
@@ -3075,6 +4313,7 @@ class LightningNode extends events_1.EventEmitter {
         }
         if (payment) {
             this.emit('payment:received', payment);
+            this.emitInvoiceSettled(paymentHash, payment);
             this.emitStructuredLog('payment', 'received', {
                 paymentHash: hashHex,
                 amountMsat: Number(payment.amountMsat),
@@ -3117,39 +4356,41 @@ class LightningNode extends events_1.EventEmitter {
         const forwardCltv = blindedOutCltv ?? hopPayload.outgoingCltvValue;
         if (!outgoingScid) {
             this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-            this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.UNKNOWN_NEXT_PEER));
+            this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.UNKNOWN_NEXT_PEER));
+            return;
+        }
+        const scidHex = outgoingScid.toString('hex');
+        const outChannelId = this.scidToChannelId.get(scidHex);
+        if (!outChannelId) {
+            this.cleanupHtlcSharedSecret(inHtlcSecretKey);
+            this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.UNKNOWN_NEXT_PEER));
             return;
         }
+        const outPolicy = this.getForwardingPolicyForChannel(outChannelId);
         if (isBlindedForward) {
             if (forwardAmount <= 0n ||
-                incomingCltvExpiry - forwardCltv < this.forwardingCltvDelta ||
+                incomingCltvExpiry - forwardCltv < outPolicy.cltvExpiryDelta ||
                 (blindedMaxCltv !== undefined && incomingCltvExpiry > blindedMaxCltv)) {
                 this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_CLTV_EXPIRY));
+                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_CLTV_EXPIRY));
                 return;
             }
         }
         else {
-            if (incomingCltvExpiry < forwardCltv + this.forwardingCltvDelta) {
+            if (incomingCltvExpiry < forwardCltv + outPolicy.cltvExpiryDelta) {
                 this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.INCORRECT_CLTV_EXPIRY));
+                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.INCORRECT_CLTV_EXPIRY));
                 return;
             }
-            const requiredFee = BigInt(this.forwardingFeeBaseMsat) +
-                (forwardAmount * BigInt(this.forwardingFeePropMillionths)) / 1000000n;
+            const requiredFee = BigInt(outPolicy.feeBaseMsat) +
+                (forwardAmount * BigInt(outPolicy.feeProportionalMillionths)) /
+                    1000000n;
             if (incomingAmountMsat < forwardAmount + requiredFee) {
                 this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.FEE_INSUFFICIENT));
+                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.FEE_INSUFFICIENT));
                 return;
             }
         }
-        const scidHex = outgoingScid.toString('hex');
-        const outChannelId = this.scidToChannelId.get(scidHex);
-        if (!outChannelId) {
-            this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-            this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.UNKNOWN_NEXT_PEER));
-            return;
-        }
         const performForward = () => {
             const nextOnionBuf = (0, construct_1.encodeOnionPacket)(nextPacket);
             const outChannel = this.channelManager.getChannel(outChannelId);
@@ -3163,7 +4404,7 @@ class LightningNode extends events_1.EventEmitter {
             if (!result.ok) {
                 this.forwardedHtlcs.delete(outKey);
                 this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.TEMPORARY_CHANNEL_FAILURE));
+                this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.TEMPORARY_CHANNEL_FAILURE));
                 return;
             }
             this.emit('htlc:forward', inChannelId, outChannelId, forwardAmount, paymentHash);
@@ -3184,7 +4425,7 @@ class LightningNode extends events_1.EventEmitter {
                 fail: () => {
                     this.heldForwards.delete(hashHex);
                     this.cleanupHtlcSharedSecret(inHtlcSecretKey);
-                    this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_2.UNKNOWN_NEXT_PEER));
+                    this.channelManager.failHtlc(inChannelId, inHtlcId, (0, failures_1.createFailureMessage)(sharedSecret, types_3.UNKNOWN_NEXT_PEER));
                 }
             });
             this.emit('htlc:held-forward', {
@@ -3235,6 +4476,7 @@ class LightningNode extends events_1.EventEmitter {
         if (forward) {
             this.cleanupHtlcSharedSecret(`${forward.inChannelId.toString('hex')}:${forward.inHtlcId}`);
             this.channelManager.recordPreimage(preimageHash, preimage);
+            this.recordForwardingEvent(channelId, htlcId, forward);
             this.safeStorage(() => this.storage.deleteForwardedHtlc(outKey), 'deleteForwardedHtlc');
             this.channelManager.fulfillHtlc(forward.inChannelId, forward.inHtlcId, preimage);
             this.forwardedHtlcs.delete(outKey);
@@ -3245,10 +4487,10 @@ class LightningNode extends events_1.EventEmitter {
         const hashHex = paymentHash.toString('hex');
         const payment = this.payments.get(hashHex);
         if (payment &&
-            payment.direction === types_5.PaymentDirection.OUTGOING &&
-            (payment.status === types_5.PaymentStatus.PENDING ||
-                payment.status === types_5.PaymentStatus.FAILED)) {
-            payment.status = types_5.PaymentStatus.COMPLETED;
+            payment.direction === types_6.PaymentDirection.OUTGOING &&
+            (payment.status === types_6.PaymentStatus.PENDING ||
+                payment.status === types_6.PaymentStatus.FAILED)) {
+            payment.status = types_6.PaymentStatus.COMPLETED;
             payment.preimage = preimage;
             payment.completedAt = Date.now();
             const retryCtx = this.paymentRetryContexts.get(hashHex);
@@ -3285,6 +4527,41 @@ class LightningNode extends events_1.EventEmitter {
             });
         }
     }
+    recordForwardingEvent(outChannelId, outHtlcId, forward) {
+        const outState = this.channelManager
+            .getChannel(outChannelId)
+            ?.getFullState();
+        const inState = this.channelManager
+            .getChannel(forward.inChannelId)
+            ?.getFullState();
+        const outHtlc = outState?.htlcs.get(`offered-${outHtlcId}`);
+        const inHtlc = inState?.htlcs.get(`received-${forward.inHtlcId}`);
+        if (!outHtlc || !inHtlc)
+            return;
+        const amountInMsat = inHtlc.amountMsat;
+        const amountOutMsat = outHtlc.amountMsat;
+        this.emit('htlc:forwarded', {
+            inChannelId: forward.inChannelId,
+            outChannelId,
+            amountInMsat,
+            amountOutMsat,
+            feeMsat: amountInMsat - amountOutMsat
+        });
+        if (!this.storage ||
+            typeof this.storage.saveForwardingEvent !== 'function') {
+            return;
+        }
+        this.safeStorage(() => this.storage.saveForwardingEvent({
+            settledAt: Date.now(),
+            inChannelId: forward.inChannelId.toString('hex'),
+            outChannelId: outChannelId.toString('hex'),
+            inScid: inState?.shortChannelId?.toString('hex'),
+            outScid: outState?.shortChannelId?.toString('hex'),
+            amountInMsat,
+            amountOutMsat,
+            feeMsat: amountInMsat - amountOutMsat
+        }), 'saveForwardingEvent');
+    }
     handleHtlcFailed(channelId, htlcId, reason) {
         const outKey = `${channelId.toString('hex')}:offered-${htlcId}`;
         const forward = this.forwardedHtlcs.get(outKey);
@@ -3306,7 +4583,7 @@ class LightningNode extends events_1.EventEmitter {
         if (!hashHex)
             return;
         const payment = this.payments.get(hashHex);
-        if (!payment || payment.direction !== types_5.PaymentDirection.OUTGOING)
+        if (!payment || payment.direction !== types_6.PaymentDirection.OUTGOING)
             return;
         let failureData;
         if (payment.sharedSecrets && reason.length > 0) {
@@ -3356,7 +4633,7 @@ class LightningNode extends events_1.EventEmitter {
             }
             retryCtx.retryCount++;
             payment.retryCount = retryCtx.retryCount;
-            payment.status = types_5.PaymentStatus.PENDING;
+            payment.status = types_6.PaymentStatus.PENDING;
             payment.failureCode = undefined;
             payment.failureSourceIndex = undefined;
             payment.completedAt = undefined;
@@ -3368,7 +4645,7 @@ class LightningNode extends events_1.EventEmitter {
             }
         }
         this.paymentRetryContexts.delete(hashHex);
-        payment.status = types_5.PaymentStatus.FAILED;
+        payment.status = types_6.PaymentStatus.FAILED;
         payment.completedAt = Date.now();
         this.htlcPaymentMap.delete(key);
         if (this.storage) {
@@ -3391,7 +4668,7 @@ class LightningNode extends events_1.EventEmitter {
             return true;
         if (failureCode & 0x8000)
             return true;
-        if (failureCode === types_2.EXPIRY_TOO_FAR)
+        if (failureCode === types_3.EXPIRY_TOO_FAR)
             return true;
         return false;
     }
@@ -3401,12 +4678,36 @@ class LightningNode extends events_1.EventEmitter {
     listPayments() {
         return [...this.payments.values()];
     }
+    listForwards(filter) {
+        if (!this.storage ||
+            typeof this.storage.listForwardingEvents !== 'function') {
+            return [];
+        }
+        try {
+            return this.storage.listForwardingEvents(filter);
+        }
+        catch {
+            return [];
+        }
+    }
+    getForwardingSummary(options) {
+        if (!this.storage ||
+            typeof this.storage.getForwardingSummary !== 'function') {
+            return { count: 0, volumeOutMsat: 0n, feesEarnedMsat: 0n };
+        }
+        try {
+            return this.storage.getForwardingSummary(options);
+        }
+        catch {
+            return { count: 0, volumeOutMsat: 0n, feesEarnedMsat: 0n };
+        }
+    }
     getPaymentProof(paymentHash) {
         const hashHex = paymentHash.toString('hex');
         const payment = this.payments.get(hashHex);
         if (!payment)
             return null;
-        if (payment.status !== types_5.PaymentStatus.COMPLETED)
+        if (payment.status !== types_6.PaymentStatus.COMPLETED)
             return null;
         if (!payment.preimage)
             return null;
@@ -3444,7 +4745,7 @@ class LightningNode extends events_1.EventEmitter {
             if (!destination)
                 return null;
             const sourceBuf = Buffer.from(this.nodeId, 'hex');
-            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, decoded.routingHints, undefined, this.getLocalChannelEdges());
+            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, decoded.routingHints, undefined, this.getLocalChannelEdges());
             if (!route)
                 return null;
             return {
@@ -3469,7 +4770,7 @@ class LightningNode extends events_1.EventEmitter {
             if (!destination)
                 return null;
             const sourceBuf = Buffer.from(this.nodeId, 'hex');
-            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, decoded.routingHints, undefined, this.getLocalChannelEdges());
+            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, decoded.routingHints, undefined, this.getLocalChannelEdges());
             if (!route)
                 return null;
             let successProbability = 1.0;
@@ -3492,7 +4793,7 @@ class LightningNode extends events_1.EventEmitter {
             const estimatedTimeMs = hopCount * 2000;
             let alternativeAvailable = false;
             try {
-                const altRoute = (0, pathfinding_1.findMultiPathRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY, undefined, undefined, this.missionControl, decoded.routingHints, undefined, this.getLocalChannelEdges());
+                const altRoute = (0, pathfinding_1.findMultiPathRoute)(this.graph, sourceBuf, destination, amountMsat, decoded.minFinalCltvExpiry || types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY, undefined, undefined, this.missionControl, decoded.routingHints, undefined, this.getLocalChannelEdges());
                 alternativeAvailable = altRoute !== null && altRoute.parts.length > 1;
             }
             catch {
@@ -3526,7 +4827,7 @@ class LightningNode extends events_1.EventEmitter {
             const amountMsat = BigInt(amountSats) * 1000n;
             const destBuf = Buffer.from(destination, 'hex');
             const sourceBuf = Buffer.from(this.nodeId, 'hex');
-            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destBuf, amountMsat, types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, undefined, undefined, this.getLocalChannelEdges());
+            const route = (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destBuf, amountMsat, types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY, 20, undefined, this.missionControl, undefined, undefined, undefined, this.getLocalChannelEdges());
             if (!route)
                 return { success: false };
             if (route.hops.length > 0) {
@@ -3542,6 +4843,10 @@ class LightningNode extends events_1.EventEmitter {
             return { success: false };
         }
     }
+    queryRoute(destination, amountMsat, finalCltvExpiry = types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY) {
+        const sourceBuf = Buffer.from(this.nodeId, 'hex');
+        return (0, pathfinding_1.findRoute)(this.graph, sourceBuf, destination, amountMsat, finalCltvExpiry, undefined, undefined, this.missionControl, undefined, undefined, undefined, this.getLocalChannelEdges());
+    }
     handlePeerMessage(pubkey, type, payload) {
         if (Buffer.isBuffer(payload) && payload.length > validation_2.MAX_MESSAGE_SIZE) {
             this.emit('node:error', {
@@ -3551,17 +4856,17 @@ class LightningNode extends events_1.EventEmitter {
             });
             return;
         }
-        if (type === types_4.MessageType.CHANNEL_ANNOUNCEMENT ||
-            type === types_4.MessageType.NODE_ANNOUNCEMENT ||
-            type === types_4.MessageType.CHANNEL_UPDATE ||
-            type === types_4.MessageType.QUERY_CHANNEL_RANGE ||
-            type === types_4.MessageType.REPLY_CHANNEL_RANGE ||
-            type === types_4.MessageType.QUERY_SHORT_CHANNEL_IDS ||
-            type === types_4.MessageType.REPLY_SHORT_CHANNEL_IDS_END ||
-            type === types_4.MessageType.GOSSIP_TIMESTAMP_FILTER) {
+        if (type === types_5.MessageType.CHANNEL_ANNOUNCEMENT ||
+            type === types_5.MessageType.NODE_ANNOUNCEMENT ||
+            type === types_5.MessageType.CHANNEL_UPDATE ||
+            type === types_5.MessageType.QUERY_CHANNEL_RANGE ||
+            type === types_5.MessageType.REPLY_CHANNEL_RANGE ||
+            type === types_5.MessageType.QUERY_SHORT_CHANNEL_IDS ||
+            type === types_5.MessageType.REPLY_SHORT_CHANNEL_IDS_END ||
+            type === types_5.MessageType.GOSSIP_TIMESTAMP_FILTER) {
             this.handleGossipMessage(pubkey, type, payload);
         }
-        if (type === types_4.MessageType.ONION_MESSAGE) {
+        if (type === types_5.MessageType.ONION_MESSAGE) {
             this.onionMessageManager.handleMessage(pubkey, payload);
         }
         this.channelManager.handleMessage(pubkey, type, payload);
@@ -3593,7 +4898,8 @@ class LightningNode extends events_1.EventEmitter {
         if (this.feeEstimator) {
             this.feeEstimator
                 .estimateFee(6)
-                .then((satPerVbyte) => {
+                .then((rawSatPerVbyte) => {
+                const satPerVbyte = this.clampEstimatedFeeRate(rawSatPerVbyte);
                 if (satPerVbyte > 0) {
                     this.feeAdvisor.recordSample(satPerVbyte);
                     for (const monitor of this.channelManager.getMonitors().values()) {
@@ -3614,6 +4920,14 @@ class LightningNode extends events_1.EventEmitter {
             return FORCE_CLOSE_DEFAULT_SAT_PER_VBYTE;
         return Math.max(Math.ceil(live * FORCE_CLOSE_FEE_MULTIPLIER), FORCE_CLOSE_DEFAULT_SAT_PER_VBYTE);
     }
+    clampEstimatedFeeRate(satPerVbyte) {
+        return (0, types_6.clampFeeRateSatPerVbyte)(satPerVbyte, (original, clamped) => {
+            this.emitStructuredLog('fee', 'estimate_clamped', {
+                original,
+                clamped
+            });
+        });
+    }
     scanExpiringHtlcs(blockHeight) {
         const claimBuffer = Math.max(LightningNode.INBOUND_HTLC_CLAIM_FORCE_CLOSE_BUFFER, this.htlcSafetyMargin);
         const channels = this.channelManager.listChannels();
@@ -3626,8 +4940,13 @@ class LightningNode extends events_1.EventEmitter {
                 if (!key.startsWith('received-'))
                     continue;
                 const paymentHashHex = htlc.paymentHash?.toString('hex');
-                const haveClaim = htlc.state === types_1.HtlcState.FULFILLED ||
-                    (paymentHashHex !== undefined && this.preimages.has(paymentHashHex));
+                const parkedHold = htlc.state !== types_1.HtlcState.FULFILLED &&
+                    paymentHashHex !== undefined &&
+                    this.heldInvoiceHashes.has(paymentHashHex);
+                const haveClaim = !parkedHold &&
+                    (htlc.state === types_1.HtlcState.FULFILLED ||
+                        (paymentHashHex !== undefined &&
+                            this.preimages.has(paymentHashHex)));
                 if (haveClaim && htlc.cltvExpiry - blockHeight <= claimBuffer) {
                     const channelId = state.channelId || state.temporaryChannelId;
                     this.emit('node:error', {
@@ -3647,7 +4966,7 @@ class LightningNode extends events_1.EventEmitter {
                     const htlcSecretKey = `${channelId.toString('hex')}:${htlc.id}`;
                     const htlcSharedSecret = this.receivedHtlcSharedSecrets.get(htlcSecretKey);
                     const reason = htlcSharedSecret
-                        ? (0, failures_1.createFailureMessage)(htlcSharedSecret, types_2.EXPIRY_TOO_SOON)
+                        ? (0, failures_1.createFailureMessage)(htlcSharedSecret, types_3.EXPIRY_TOO_SOON)
                         : Buffer.alloc(290);
                     this.cleanupHtlcSharedSecret(htlcSecretKey);
                     this.channelManager.failHtlc(channelId, htlc.id, reason);
@@ -3689,7 +5008,7 @@ class LightningNode extends events_1.EventEmitter {
                     const htlcSecretKey = `${channelId.toString('hex')}:${htlc.id}`;
                     const sharedSecret = this.receivedHtlcSharedSecrets.get(htlcSecretKey);
                     const reason = sharedSecret
-                        ? (0, failures_1.createFailureMessage)(sharedSecret, types_2.EXPIRY_TOO_SOON)
+                        ? (0, failures_1.createFailureMessage)(sharedSecret, types_3.EXPIRY_TOO_SOON)
                         : Buffer.alloc(290);
                     this.cleanupHtlcSharedSecret(htlcSecretKey);
                     this.channelManager.failHtlc(channelId, htlc.id, reason);
@@ -3775,8 +5094,13 @@ class LightningNode extends events_1.EventEmitter {
             feeEstimator: options?.feeEstimator,
             socks5Proxy: options?.socks5Proxy,
             preferAnchors: options?.preferAnchors,
+            largeChannels: options?.largeChannels,
             chainBackend: options?.chainBackend,
             sweepDestinationScript: options?.sweepDestinationScript,
+            peerStorageEnabled: options?.peerStorageEnabled,
+            autoRebalance: options?.autoRebalance,
+            autoTuneFees: options?.autoTuneFees,
+            watchtowers: options?.watchtowers,
             channelKeyDeriver
         });
     }
@@ -3797,6 +5121,9 @@ class LightningNode extends events_1.EventEmitter {
         flags.setOptional(flags_1.Feature.ANCHOR_ZERO_FEE_HTLC);
         flags.setOptional(flags_1.Feature.SHUTDOWN_ANY_SEGWIT);
         flags.setOptional(flags_1.Feature.SIMPLE_CLOSE);
+        flags.setOptional(flags_1.Feature.DUAL_FUND);
+        flags.setOptional(flags_1.Feature.ZERO_CONF);
+        flags.setOptional(flags_1.Feature.PROVIDE_STORAGE);
         return flags;
     }
     sendOnionMessage(destination, messageData, options) {
@@ -3829,7 +5156,7 @@ class LightningNode extends events_1.EventEmitter {
                 }
             }
         });
-        this.peerManager.onMessage(types_4.MessageType.ONION_MESSAGE, (pubkey, _type, payload) => {
+        this.peerManager.onMessage(types_5.MessageType.ONION_MESSAGE, (pubkey, _type, payload) => {
             this.onionMessageManager.handleMessage(pubkey, payload);
         });
     }
@@ -3859,7 +5186,7 @@ class LightningNode extends events_1.EventEmitter {
         }
         const destination = invoice.nodeId;
         const amountMsat = invoice.amount;
-        const finalCltvExpiry = types_3.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
+        const finalCltvExpiry = types_4.DEFAULT_MIN_FINAL_CLTV_EXPIRY;
         const sourceNodeId = (0, ecdh_1.getPublicKey)(this.nodePrivkey);
         if (invoice.paths && invoice.paths.length > 0) {
             const payInfo = invoice.blindedPayInfo?.[0] ?? {
@@ -3902,7 +5229,7 @@ class LightningNode extends events_1.EventEmitter {
                 bolt11: '',
                 amountMsat: invoice.amount,
                 description: invoice.description,
-                expiry: invoice.relativeExpiry ?? types_3.DEFAULT_EXPIRY,
+                expiry: invoice.relativeExpiry ?? types_4.DEFAULT_EXPIRY,
                 createdAt: Number(invoice.createdAt)
             };
             this.invoices.set(hashHex, invoiceInfo);
@@ -3911,8 +5238,8 @@ class LightningNode extends events_1.EventEmitter {
                     paymentHash: invoice.paymentHash,
                     preimage,
                     amountMsat: invoice.amount,
-                    status: types_5.PaymentStatus.PENDING,
-                    direction: types_5.PaymentDirection.INCOMING,
+                    status: types_6.PaymentStatus.PENDING,
+                    direction: types_6.PaymentDirection.INCOMING,
                     createdAt: Date.now()
                 });
             }
@@ -3972,9 +5299,9 @@ class LightningNode extends events_1.EventEmitter {
     failPayment(paymentHash) {
         const hashHex = paymentHash.toString('hex');
         const payment = this.payments.get(hashHex);
-        if (!payment || payment.status !== types_5.PaymentStatus.PENDING)
+        if (!payment || payment.status !== types_6.PaymentStatus.PENDING)
             return;
-        payment.status = types_5.PaymentStatus.FAILED;
+        payment.status = types_6.PaymentStatus.FAILED;
         payment.completedAt = Date.now();
         this.paymentRetryContexts.delete(hashHex);
         this.outboundMppPayments.delete(hashHex);
@@ -4008,9 +5335,9 @@ class LightningNode extends events_1.EventEmitter {
             }
         }
         for (const [hashHex, payment] of this.payments) {
-            if (payment.status !== types_5.PaymentStatus.PENDING)
+            if (payment.status !== types_6.PaymentStatus.PENDING)
                 continue;
-            if (payment.direction !== types_5.PaymentDirection.OUTGOING)
+            if (payment.direction !== types_6.PaymentDirection.OUTGOING)
                 continue;
             if (now - payment.createdAt < TEN_MINUTES)
                 continue;
@@ -4022,9 +5349,9 @@ class LightningNode extends events_1.EventEmitter {
     scanExpiredPendingPayments() {
         const now = Math.floor(Date.now() / 1000);
         for (const [hashHex, payment] of this.payments) {
-            if (payment.status !== types_5.PaymentStatus.PENDING)
+            if (payment.status !== types_6.PaymentStatus.PENDING)
                 continue;
-            if (payment.direction !== types_5.PaymentDirection.OUTGOING)
+            if (payment.direction !== types_6.PaymentDirection.OUTGOING)
                 continue;
             const retryCtx = this.paymentRetryContexts.get(hashHex);
             if (!retryCtx)
@@ -4162,10 +5489,10 @@ class LightningNode extends events_1.EventEmitter {
         const hashHex = paymentHash.toString('hex');
         const existing = this.payments.get(hashHex);
         if (existing) {
-            if (existing.status === types_5.PaymentStatus.COMPLETED) {
+            if (existing.status === types_6.PaymentStatus.COMPLETED) {
                 return Promise.resolve(existing);
             }
-            if (existing.status === types_5.PaymentStatus.FAILED) {
+            if (existing.status === types_6.PaymentStatus.FAILED) {
                 return Promise.reject(new Error(`Payment already failed${existing.failureCode !== undefined
                     ? ` (code ${existing.failureCode})`
                     : ''}`));
@@ -4232,6 +5559,9 @@ class LightningNode extends events_1.EventEmitter {
         for (const channel of channels) {
             const state = channel.getFullState();
             const channelId = state.channelId || state.temporaryChannelId;
+            if (state.dataLossDetected) {
+                continue;
+            }
             const effectiveState = state.state === types_1.ChannelState.AWAITING_REESTABLISH
                 ? state.preReestablishState || state.state
                 : state.state;
@@ -4307,11 +5637,11 @@ class LightningNode extends events_1.EventEmitter {
     async checkAndUpdateFees() {
         if (!this.feeEstimator)
             return;
-        const satPerVbyte = await this.feeEstimator.estimateFee(6);
+        const satPerVbyte = this.clampEstimatedFeeRate(await this.feeEstimator.estimateFee(6));
         if (satPerVbyte <= 0)
             return;
         this.feeAdvisor.recordSample(satPerVbyte);
-        const newFeeratePerKw = Math.max((0, types_6.satPerVbyteToSatPerKw)(satPerVbyte), types_6.MIN_FEERATE_PER_KW);
+        const newFeeratePerKw = Math.max((0, types_7.satPerVbyteToSatPerKw)(satPerVbyte), types_7.MIN_FEERATE_PER_KW);
         if (this.lastKnownFeeratePerKw > 0) {
             const ratio = newFeeratePerKw / this.lastKnownFeeratePerKw;
             if (ratio > 0.8 && ratio < 1.2)
@@ -4405,6 +5735,22 @@ class LightningNode extends events_1.EventEmitter {
             }
         }
     }
+    findLocalChannelByScid(scid, peerPubkeyHex) {
+        if (!scid || scid.length === 0 || scid.equals(Buffer.alloc(scid.length))) {
+            return undefined;
+        }
+        for (const channel of this.channelManager.getChannelsByPeer(peerPubkeyHex)) {
+            if (channel.getState() !== types_1.ChannelState.NORMAL)
+                continue;
+            const st = channel.getFullState();
+            if ((st.shortChannelId && st.shortChannelId.equals(scid)) ||
+                (st.scidAlias && st.scidAlias.equals(scid)) ||
+                (st.remoteScidAlias && st.remoteScidAlias.equals(scid))) {
+                return channel;
+            }
+        }
+        return undefined;
+    }
     findChannelForPeer(peerPubkeyHex, amountMsat) {
         const channels = this.channelManager.getChannelsByPeer(peerPubkeyHex);
         const normalChannels = channels.filter((ch) => ch.getState() === types_1.ChannelState.NORMAL);
@@ -4430,7 +5776,9 @@ class LightningNode extends events_1.EventEmitter {
     }
 }
 exports.LightningNode = LightningNode;
+LightningNode.PEER_STORAGE_MIN_INTERVAL_MS = 60000;
 LightningNode.SPLICE_MIN_AMOUNT_SATS = 546n;
+LightningNode.REBALANCE_BUDGET_KEY = 'advisor:rebalance-budget';
 LightningNode.INBOUND_HTLC_CLAIM_FORCE_CLOSE_BUFFER = 18;
 LightningNode.OFFERED_HTLC_FORCE_CLOSE_GRACE_BLOCKS = 6;
 //# sourceMappingURL=lightning-node.js.map