beignet 0.2.0 → 0.4.0

package/dist/types/lightning/crypto/xchacha20poly1305.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function encrypt(key: Buffer, nonce: Buffer, plaintext: Buffer, aad?: Buffer): Buffer;
+export declare function decrypt(key: Buffer, nonce: Buffer, ciphertextWithTag: Buffer, aad?: Buffer): Buffer;

package/dist/types/lightning/features/flags.d.ts

@@ -15,6 +15,7 @@ export declare enum Feature {
     SHUTDOWN_ANY_SEGWIT = 26,
     DUAL_FUND = 28,
     ONION_MESSAGES = 38,
+    PROVIDE_STORAGE = 42,
     QUIESCE = 34,
     CHANNEL_TYPE = 44,
     SCID_ALIAS = 46,

package/dist/types/lightning/gossip/messages.d.ts

@@ -13,4 +13,8 @@ export declare function decodeNodeAddress(buf: Buffer, offset: number): {
     address: INodeAddress;
     bytesRead: number;
 };
+export declare function nodeAddressToHostPort(addr: INodeAddress): {
+    host: string;
+    port: number;
+} | null;
 export declare function parseAnnouncedAddress(input: string): INodeAddress;

package/dist/types/lightning/index.d.ts

@@ -18,3 +18,4 @@ export * as bootstrap from './bootstrap';
 export * as interactiveTx from './interactive-tx';
 export * as offer from './offer';
 export * as advisor from './advisor';
+export * as backup from './backup';

package/dist/types/lightning/keys/signer.d.ts

@@ -1,12 +1,29 @@
 /// <reference types="node" />
 import * as bitcoin from 'bitcoinjs-lib';
 import { type SessionKey } from '../crypto/musig';
-export declare class ChannelSigner {
+export interface ISigner {
+    readonly fundingPubkey: Buffer;
+    readonly hasHtlcKeys: boolean;
+    signFundingDigest(digest: Buffer): Buffer;
+    signCommitmentTx(tx: bitcoin.Transaction, fundingWitnessScript: Buffer, fundingAmount: number): Buffer;
+    signClosingTx(tx: bitcoin.Transaction, fundingWitnessScript: Buffer, fundingAmount: number): Buffer;
+    signCommitmentPartial(session: SessionKey, ourPublicNonce: Uint8Array): Buffer;
+    signHtlcTxForCommitment(tx: bitcoin.Transaction, htlcWitnessScript: Buffer, htlcAmount: number, perCommitmentPoint: Buffer, htlcBasepoint: Buffer, useAnchorSighash?: boolean): Buffer;
+    signTaprootHtlcForCommitment(sighash: Buffer, perCommitmentPoint: Buffer, htlcBasepoint: Buffer): Buffer;
+    verifyCommitmentSig(tx: bitcoin.Transaction, signature: Buffer, remoteFundingPubkey: Buffer, fundingWitnessScript: Buffer, fundingAmount: number): boolean;
+}
+export type SignerFactory = (channelKeyIndex: number) => ISigner;
+export declare function verifyCommitmentSignature(tx: bitcoin.Transaction, signature: Buffer, remoteFundingPubkey: Buffer, fundingWitnessScript: Buffer, fundingAmount: number): boolean;
+export declare class ChannelSigner implements ISigner {
     private fundingPrivkey;
     readonly fundingPubkey: Buffer;
     private _htlcBasepointSecret;
     constructor(fundingPrivkey: Buffer, htlcBasepointSecret?: Buffer);
     get htlcBasepointSecret(): Buffer | undefined;
+    get hasHtlcKeys(): boolean;
+    private deriveHtlcPrivkey;
+    signHtlcTxForCommitment(tx: bitcoin.Transaction, htlcWitnessScript: Buffer, htlcAmount: number, perCommitmentPoint: Buffer, htlcBasepoint: Buffer, useAnchorSighash?: boolean): Buffer;
+    signTaprootHtlcForCommitment(sighash: Buffer, perCommitmentPoint: Buffer, htlcBasepoint: Buffer): Buffer;
     signFundingDigest(digest: Buffer): Buffer;
     signCommitmentPartial(session: SessionKey, ourPublicNonce: Uint8Array): Buffer;
     signCommitmentTx(tx: bitcoin.Transaction, fundingWitnessScript: Buffer, fundingAmount: number): Buffer;

package/dist/types/lightning/keys/wallet-keys.d.ts

@@ -4,7 +4,8 @@ import { IChannelBasepoints } from './derivation';
 export declare enum LnCoinType {
     BITCOIN = 0,
     TESTNET = 1,
-    REGTEST = 1
+    REGTEST = 1,
+    SIGNET = 1
 }
 export interface ILightningKeysFromSeed {
     nodePrivateKey: Buffer;

package/dist/types/lightning/message/index.d.ts

@@ -11,6 +11,7 @@ export * from './channel-commitment';
 export * from './channel-close';
 export * from './channel-reestablish';
 export * from './stfu';
+export * from './peer-storage';
 export * from './interactive-tx';
 export * from './dual-funding';
 export * from './splice';

package/dist/types/lightning/message/peer-storage.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export declare const PEER_STORAGE_MAX_BYTES = 65531;
+export interface IPeerStorageMessage {
+    blob: Buffer;
+}
+export declare function encodePeerStorageMessage(msg: IPeerStorageMessage): Buffer;
+export declare function decodePeerStorageMessage(payload: Buffer): IPeerStorageMessage;
+export declare function encodePeerStorageRetrievalMessage(msg: IPeerStorageMessage): Buffer;
+export declare function decodePeerStorageRetrievalMessage(payload: Buffer): IPeerStorageMessage;

package/dist/types/lightning/message/types.d.ts

@@ -4,6 +4,8 @@ export declare enum MessageType {
     WARNING = 1,
     PING = 18,
     PONG = 19,
+    PEER_STORAGE = 7,
+    PEER_STORAGE_RETRIEVAL = 9,
     OPEN_CHANNEL = 32,
     ACCEPT_CHANNEL = 33,
     FUNDING_CREATED = 34,

package/dist/types/lightning/node/lightning-node.d.ts

@@ -1,17 +1,20 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { EventEmitter } from 'events';
+import { ILogger } from '../../logger';
 import { ChannelManager } from '../channel/channel-manager';
 import { Channel } from '../channel/channel';
 import { PeerManager, IPeerInfo } from '../transport/peer-manager';
 import { NetworkGraph } from '../gossip/network-graph';
 import { IRapidGossipResult } from '../gossip/rapid-sync';
-import { INodeAddress } from '../gossip/types';
+import { INodeAddress, IRoute } from '../gossip/types';
 import { Network } from '../invoice/types';
-import { INodeConfig, IPaymentInfo, ICreateInvoiceOptions, ICreateInvoiceResult, IChannelInfo, INodeInfo, ILightningBalance, IFundingProvider, IFeeEstimator, IInvoiceInfo, IChannelHealth, IStructuredLog, IPaymentProof, IPaymentEstimate, IKeysendOptions } from './types';
-import { IStorageBackend } from '../storage/types';
+import { INodeConfig, IPaymentInfo, ICreateInvoiceOptions, ICreateInvoiceResult, IChannelInfo, INodeInfo, ILightningBalance, IFundingProvider, IFeeEstimator, IInvoiceInfo, IChannelHealth, IStructuredLog, IPaymentProof, IPaymentEstimate, IKeysendOptions, IChannelPolicy, IChannelPolicyUpdate, IAutoRebalanceConfig, IAutoTuneFeesConfig, IRebalanceResult, IRebalanceExecutionSummary } from './types';
+import { IStorageBackend, IForwardingEvent, IForwardingEventFilter, IForwardingSummary } from '../storage/types';
 import { FeatureFlags } from '../features/flags';
 import { ChainWatcher } from '../chain/chain-watcher';
+import { WatchtowerClient } from '../watchtower';
+import { IScbChannelEntry } from '../backup/scb';
 import { IPeerAddress, IBootstrapConfig } from '../bootstrap';
 import { OnionMessageManager } from '../onion-message/manager';
 import { AsyncPaymentManager } from '../async-payments/manager';
@@ -21,6 +24,8 @@ import { IOffer, IBolt12Invoice } from '../offer/types';
 import { ILiquiditySnapshot } from '../advisor/liquidity-advisor';
 import { IFeeSnapshot } from '../advisor/fee-advisor';
 import { IChannelSuggestion } from '../advisor/channel-suggestions';
+import { IRebalancePlan } from '../advisor/rebalance-planner';
+import { IFeeTuneAdjustment } from '../advisor/fee-tuner';
 export declare class LightningNode extends EventEmitter {
     private nodePrivkey;
     private acceptableChainHashes;
@@ -45,6 +50,7 @@ export declare class LightningNode extends EventEmitter {
     private forwardingCltvDelta;
     private forwardingFeeBaseMsat;
     private forwardingFeePropMillionths;
+    private channelPolicies;
     private gossipSyncManagers;
     private _ownNodeAnnouncement?;
     private _ownChannelGossip;
@@ -58,6 +64,7 @@ export declare class LightningNode extends EventEmitter {
     private fundingPubkey;
     private fundingProvider;
     private fundingPrivkey;
+    private signerFactory;
     private sweepDestinationScript?;
     private htlcBasepointSecret;
     private delayedPaymentBasepointSecret;
@@ -69,6 +76,7 @@ export declare class LightningNode extends EventEmitter {
     private receivedHtlcSharedSecrets;
     private feeEstimator;
     private missionControl;
+    private logger;
     private maxPaymentRetries;
     private maxTotalInFlightHtlcs;
     private autoUpdateChannelFees;
@@ -95,6 +103,20 @@ export declare class LightningNode extends EventEmitter {
     private liquidityAdvisor;
     private feeAdvisor;
     private channelSuggestions;
+    private autoRebalanceConfig;
+    private autoTuneFeesConfig;
+    private autoRebalanceTimer;
+    private autoTuneFeesTimer;
+    private rebalanceBudgetDay;
+    private rebalanceRunInFlight;
+    private peerStorageEnabled;
+    private largeChannels;
+    private socks5Proxy;
+    private watchtowerClient;
+    private peerStorageBlobs;
+    private peerStorageLastAccepted;
+    private ourPeerStorageBlob;
+    private retrievedPeerStorage;
     constructor(config: INodeConfig);
     private restoreFromStorage;
     private persistChannel;
@@ -105,13 +127,50 @@ export declare class LightningNode extends EventEmitter {
     private makeAnnouncementSigner;
     private triggerPendingAnnouncementSigning;
     private registerGossipHandlers;
+    private static readonly PEER_STORAGE_MIN_INTERVAL_MS;
+    private registerPeerStorageHandlers;
+    private handlePeerStorageMessage;
+    private handlePeerStorageRetrievalMessage;
+    private peerQualifiesForStorage;
+    private sendPeerStorageOnConnect;
+    private peerAdvertisesPeerStorage;
+    distributePeerStorage(blob: Buffer): number;
+    getRetrievedPeerStorage(): Array<{
+        peerPubkey: string;
+        blob: Buffer;
+        receivedAt: number;
+    }>;
     private wirePeerManagerEvents;
     private autoReconnectPeers;
     private emitReady;
     private handleAutoFunding;
     getNodeId(): string;
+    signMessage(message: string): string;
+    verifyMessage(message: string, signature: string): {
+        valid: boolean;
+        pubkey: string | null;
+        knownNode: boolean;
+    };
     getNodeInfo(): INodeInfo;
+    buildStaticChannelBackupData(): {
+        network: string;
+        channels: IScbChannelEntry[];
+    };
+    recoverFromStaticChannelBackup(entries: IScbChannelEntry[]): Promise<{
+        recovering: string[];
+        skipped: Array<{
+            channelId: string;
+            reason: string;
+        }>;
+    }>;
+    private contactRecoveryPeer;
     getSweepDestinationScript(): Buffer;
+    private getBitcoinNetwork;
+    private initWatchtowerClient;
+    private backupRevokedStateToTowers;
+    addWatchtower(uri: string): void;
+    removeWatchtower(uri: string): void;
+    getWatchtowers(): ReturnType<WatchtowerClient['getHealth']>;
     setSweepDestinationScript(destinationScript: Buffer): void;
     recoverFallbackFunds(opts?: {
         feeRatePerVbyte?: number;
@@ -125,7 +184,8 @@ export declare class LightningNode extends EventEmitter {
     loadRapidGossipSnapshot(data: Buffer): IRapidGossipResult;
     getChannelManager(): ChannelManager;
     getPeerManager(): PeerManager | null;
-    connectPeer(pubkey: string, host: string, port: number): Promise<void>;
+    connectPeer(pubkey: string, host?: string, port?: number): Promise<void>;
+    private connectPeerById;
     disconnectPeer(pubkey: string): void;
     listPeers(): IPeerInfo[];
     isNetworkingEnabled(): boolean;
@@ -136,6 +196,7 @@ export declare class LightningNode extends EventEmitter {
     private wireChainWatcherEvents;
     startChainWatcher(): Promise<void>;
     restoreChainWatches(): Promise<void>;
+    private watchRecoveredFundingOutput;
     bootstrapPeers(config?: IBootstrapConfig): Promise<IPeerAddress[]>;
     connectToSeeds(maxPeers?: number, config?: IBootstrapConfig): Promise<string[]>;
     addTrustedPeer(pubkeyHex: string): void;
@@ -166,6 +227,13 @@ export declare class LightningNode extends EventEmitter {
         ok: boolean;
         error?: string;
     };
+    setChannelPolicy(channelId: Buffer | 'all', policy: IChannelPolicyUpdate): void;
+    getChannelPolicy(channelId: Buffer): IChannelPolicy | null;
+    private getForwardingPolicyForChannel;
+    private validateChannelPolicyFields;
+    private static serializeChannelPolicy;
+    private regenerateChannelUpdateForPolicy;
+    private buildDirectChannelUpdate;
     forceCloseChannel(channelId: Buffer, destinationScript: Buffer): {
         ok: boolean;
         error?: string;
@@ -185,6 +253,23 @@ export declare class LightningNode extends EventEmitter {
     getChannel(channelId: Buffer): IChannelInfo | undefined;
     getChannelHealth(channelId: Buffer): IChannelHealth | null;
     getLiquiditySnapshot(): ILiquiditySnapshot;
+    planRebalanceRecommendations(minImbalancePct?: number): IRebalancePlan[];
+    rebalanceChannel(options: {
+        fromChannelId: Buffer;
+        toChannelId: Buffer;
+        amountSats: bigint;
+        maxFeeSats: bigint;
+        timeoutMs?: number;
+    }): Promise<IRebalanceResult>;
+    private static readonly REBALANCE_BUDGET_KEY;
+    private static currentUtcDay;
+    private loadRebalanceSpentMsat;
+    private recordRebalanceSpend;
+    executeRebalanceRecommendations(options?: {
+        budgetSatsPerDay?: number;
+        minImbalancePct?: number;
+    }): Promise<IRebalanceExecutionSummary>;
+    runFeeTuneOnce(now?: number): IFeeTuneAdjustment[];
     getFeeSnapshot(): IFeeSnapshot | null;
     getChannelSuggestions(count?: number): IChannelSuggestion[];
     private buildChannelInfo;
@@ -196,6 +281,7 @@ export declare class LightningNode extends EventEmitter {
     private broadcastOwnGossip;
     private startGossipRefresh;
     private getPrivateChannelRoutingHints;
+    private buildRoutingHintForChannel;
     private findBlindedIntroExtension;
     private buildBlindedPaymentPaths;
     private handleGossipMessage;
@@ -225,7 +311,23 @@ export declare class LightningNode extends EventEmitter {
     private handleFinalHopHtlc;
     private parkHeldHtlc;
     settleHeldHtlc(paymentHash: Buffer, preimage?: Buffer): boolean;
+    private emitInvoiceSettled;
     cancelHeldHtlc(paymentHash: Buffer, failureCode?: number): boolean;
+    private markHoldInvoiceCancelled;
+    cancelHoldInvoice(paymentHash: Buffer): {
+        htlcsFailed: number;
+    } | null;
+    listHoldInvoices(): Array<{
+        paymentHash: string;
+        bolt11: string;
+        amountMsat?: bigint;
+        description?: string;
+        expiry: number;
+        createdAt: number;
+        state: 'OPEN' | 'ACCEPTED' | 'SETTLED' | 'CANCELLED';
+        heldAmountMsat: bigint;
+        htlcCount: number;
+    }>;
     private scanExpiringHeldHtlcs;
     private persistHeldHtlcs;
     listHeldHtlcs(): Array<{
@@ -245,10 +347,15 @@ export declare class LightningNode extends EventEmitter {
     private handleForwardHtlc;
     private handleOnChainPreimageLearned;
     private handleHtlcFulfilled;
+    private recordForwardingEvent;
     private handleHtlcFailed;
     private isPermanentFailure;
     getPayment(paymentHash: Buffer): IPaymentInfo | undefined;
     listPayments(): IPaymentInfo[];
+    listForwards(filter?: IForwardingEventFilter): IForwardingEvent[];
+    getForwardingSummary(options?: {
+        since?: number;
+    }): IForwardingSummary;
     getPaymentProof(paymentHash: Buffer): IPaymentProof | null;
     setPaymentMetadata(paymentHash: Buffer, metadata: Record<string, string>): void;
     estimateRouteFee(bolt11: string, amountSats?: number): {
@@ -262,11 +369,13 @@ export declare class LightningNode extends EventEmitter {
         feeSats?: number;
         hops?: number;
     };
+    queryRoute(destination: Buffer, amountMsat: bigint, finalCltvExpiry?: number): IRoute | null;
     handlePeerMessage(pubkey: string, type: number, payload: Buffer): void;
     handleFundingSpent(channelId: Buffer, spendingTx: import('bitcoinjs-lib').Transaction, blockHeight: number, destinationScript: Buffer): void;
     handleNewBlock(blockHeight: number): void;
     getCurrentBlockHeight(): number;
     private resolveForceCloseFeeRatePerVbyte;
+    private clampEstimatedFeeRate;
     private static readonly INBOUND_HTLC_CLAIM_FORCE_CLOSE_BUFFER;
     private scanExpiringHtlcs;
     private scanForwardTimeouts;
@@ -284,15 +393,21 @@ export declare class LightningNode extends EventEmitter {
         announcedAddresses?: INodeAddress[];
         fundingProvider?: IFundingProvider;
         feeEstimator?: IFeeEstimator;
+        logger?: ILogger;
         socks5Proxy?: {
             host: string;
             port: number;
         };
         preferAnchors?: boolean;
+        largeChannels?: boolean;
         chainBackend?: import('../chain/chain-watcher').IChainBackend;
         autoReconnect?: boolean;
         autoUpdateChannelFees?: boolean;
         sweepDestinationScript?: Buffer;
+        peerStorageEnabled?: boolean;
+        autoRebalance?: IAutoRebalanceConfig;
+        autoTuneFees?: IAutoTuneFeesConfig;
+        watchtowers?: string[];
         channelKeyDeriver?: (channelIndex: number) => import('../channel/channel-manager').IPerChannelKeys;
     }): LightningNode;
     static defaultFeatures(): FeatureFlags;
@@ -338,5 +453,6 @@ export declare class LightningNode extends EventEmitter {
         limit?: number;
     }): IStructuredLog[];
     private cleanupHtlcSharedSecret;
+    private findLocalChannelByScid;
     private findChannelForPeer;
 }

package/dist/types/lightning/node/types.d.ts

@@ -6,7 +6,9 @@ import { IRoute, INodeAddress } from '../gossip/types';
 import { FeatureFlags } from '../features/flags';
 import { IStorageBackend, IInvoiceInfo } from '../storage/types';
 import { IChainBackend } from '../chain/chain-watcher';
+import { ILogger } from '../../logger';
 import { IPerChannelKeys } from '../channel/channel-manager';
+import { SignerFactory } from '../keys/signer';
 export type { IInvoiceInfo };
 export interface IResourceConfig {
     maxCompletedPayments?: number;
@@ -16,6 +18,8 @@ export interface IResourceConfig {
 export interface IFeeEstimator {
     estimateFee(targetBlocks: number): Promise<number>;
 }
+export declare const MAX_FEE_RATE_SAT_PER_VBYTE = 5000;
+export declare function clampFeeRateSatPerVbyte(satPerVbyte: number, onClamp?: (original: number, clamped: number) => void): number;
 export interface IFundingProvider {
     buildFundingTransaction(address: string, amountSats: bigint, satsPerByte?: number): Promise<{
         txHex: string;
@@ -39,6 +43,7 @@ export interface INodeConfig {
     channelBasepoints: IChannelBasepoints;
     perCommitmentSeed: Buffer;
     fundingPrivkey: Buffer;
+    signerFactory?: SignerFactory;
     htlcBasepointSecret?: Buffer;
     revocationBasepointSecret?: Buffer;
     paymentBasepointSecret?: Buffer;
@@ -63,9 +68,13 @@ export interface INodeConfig {
         host: string;
         port: number;
     };
+    watchtowers?: string[];
     preferAnchors?: boolean;
+    largeChannels?: boolean;
     preferTaproot?: boolean;
+    peerStorageEnabled?: boolean;
     feeEstimator?: IFeeEstimator;
+    logger?: ILogger;
     maxPaymentRetries?: number;
     maxTotalInFlightHtlcs?: number;
     nextChannelIndex?: number;
@@ -77,6 +86,42 @@ export interface INodeConfig {
     reestablishTimeoutBlocks?: number;
     autoUpdateChannelFees?: boolean;
     sweepDestinationScript?: Buffer;
+    autoRebalance?: IAutoRebalanceConfig;
+    autoTuneFees?: IAutoTuneFeesConfig;
+}
+export interface IAutoRebalanceConfig {
+    enabled?: boolean;
+    budgetSatsPerDay?: number;
+    minImbalancePct?: number;
+    intervalMs?: number;
+}
+export interface IAutoTuneFeesConfig {
+    enabled?: boolean;
+    intervalMs?: number;
+    floorPpm?: number;
+    ceilPpm?: number;
+}
+export interface IRebalanceResult {
+    paymentHash: Buffer;
+    amountMsat: bigint;
+    feeMsat: bigint;
+    hops: number;
+}
+export interface IRebalanceAttempt {
+    fromChannelId: string;
+    toChannelId: string;
+    amountSats: bigint;
+    status: 'SUCCEEDED' | 'FAILED' | 'SKIPPED_BUDGET';
+    feeMsat?: bigint;
+    error?: string;
+}
+export interface IRebalanceExecutionSummary {
+    attempts: IRebalanceAttempt[];
+    succeeded: number;
+    failed: number;
+    skippedBudget: number;
+    feeSpentMsat: bigint;
+    budgetRemainingMsat: bigint;
 }
 export declare enum PaymentStatus {
     PENDING = "PENDING",
@@ -137,6 +182,26 @@ export interface IChannelInfo {
     localReserveMsat?: bigint;
     remoteReserveMsat?: bigint;
     isPrivate?: boolean;
+    feeBaseMsat?: number;
+    feeProportionalMillionths?: number;
+    cltvExpiryDelta?: number;
+    htlcMinimumMsat?: bigint;
+    htlcMaximumMsat?: bigint;
+}
+export interface IChannelPolicyUpdate {
+    feeBaseMsat?: number;
+    feeProportionalMillionths?: number;
+    cltvExpiryDelta?: number;
+    htlcMinimumMsat?: bigint;
+    htlcMaximumMsat?: bigint;
+}
+export interface IChannelPolicy {
+    feeBaseMsat: number;
+    feeProportionalMillionths: number;
+    cltvExpiryDelta: number;
+    htlcMinimumMsat: bigint;
+    htlcMaximumMsat: bigint;
+    source: 'override' | 'default';
 }
 export interface INodeInfo {
     nodeId: string;
@@ -225,7 +290,7 @@ export interface IChannelHealth {
     warnings: string[];
 }
 export interface IStructuredLog {
-    category: 'payment' | 'channel' | 'htlc' | 'fee' | 'peer' | 'chain';
+    category: 'payment' | 'channel' | 'htlc' | 'fee' | 'peer' | 'chain' | 'watchtower';
     action: string;
     timestamp: number;
     data: Record<string, unknown>;

package/dist/types/lightning/storage/encryption.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+export declare function hkdfKey(secret: Buffer, info: string): Buffer;
+export declare function deriveStorageKey(secret: Buffer): Buffer;
+export declare function encryptWithPrefix(key: Buffer, plaintext: string, prefix: string): string;
+export declare function decryptWithPrefix(key: Buffer, value: string, prefix: string): string;
+export declare function encryptValue(key: Buffer, plaintext: string): string;
+export declare function decryptValue(key: Buffer, value: string): string;
+export declare function isEncryptedValue(value: string): boolean;
+export declare class StorageEncryptedError extends Error {
+    constructor();
+}

package/dist/types/lightning/storage/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types';
 export * from './serialization';
 export * from './sqlite-storage';
+export * from './encryption';

package/dist/types/lightning/storage/serialization.d.ts

@@ -163,6 +163,8 @@ export interface ISerializedChannelState {
     isLessor?: boolean;
     leaseExpiry?: number;
     lastCooperativeCloseTxHex?: string;
+    dataLossDetected?: boolean;
+    dlpRemotePerCommitmentPoint?: string | null;
 }
 export interface ISerializedSpliceInFlight {
     spliceTxid: string;

package/dist/types/lightning/storage/sqlite-storage.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import { IStorageBackend, IInvoiceInfo } from './types';
+import { IStorageBackend, IInvoiceInfo, IPersistedChannelPolicy, IForwardingEvent, IForwardingEventFilter, IForwardingSummary } from './types';
+import { IWatchtowerSession, IWatchtowerUpdate } from '../watchtower/types';
 import { IChannelState } from '../channel/channel-state';
 import { IPaymentInfo } from '../node/types';
 import { IChainMonitorState } from '../chain/chain-monitor';
@@ -7,15 +8,23 @@ import { IGraphChannel, IGraphNode } from '../gossip/types';
 export declare class SqliteStorage implements IStorageBackend {
     private db;
     private onCorruptRow?;
-    constructor(dbPath: string, onCorruptRow?: (error: unknown) => void);
+    private encryptionKey?;
+    constructor(dbPath: string, onCorruptRow?: (error: unknown) => void, opts?: {
+        encryptionKey?: Buffer;
+    });
     private reportCorruptRow;
+    private _enc;
+    private _dec;
     open(opts?: {
         synchronous?: 'FULL' | 'NORMAL';
     }): void;
     checkpoint(): void;
     close(): void;
     backup(destPath: string): Promise<void>;
-    static readonly CURRENT_SCHEMA_VERSION = 2;
+    static readonly CURRENT_SCHEMA_VERSION = 9;
+    forwardingEventsMaxRows: number;
+    private static readonly ENCRYPTED_COLUMNS;
+    private _encryptExistingData;
     private _createTables;
     saveChannel(id: string, state: IChannelState, peerPubkey: string): void;
     loadChannel(id: string): {
@@ -92,6 +101,7 @@ export declare class SqliteStorage implements IStorageBackend {
     }>;
     deletePeerAddress(pubkey: string): void;
     saveChannelKeyIndex(channelId: string, channelIndex: number): void;
+    private _decodeChannelIndex;
     loadChannelKeyIndex(channelId: string): number | null;
     loadNextChannelIndex(): number;
     saveHtlcSharedSecret(key: string, secret: Buffer): void;
@@ -120,6 +130,36 @@ export declare class SqliteStorage implements IStorageBackend {
     private _runMigrations;
     saveMetadata(key: string, value: string): void;
     loadMetadata(key: string): string | null;
+    saveWalletData(key: string, value: string): void;
+    loadWalletData(key: string): string | null;
+    saveChannelPolicy(channelId: string, policy: IPersistedChannelPolicy): void;
+    loadAllChannelPolicies(): Array<{
+        channelId: string;
+        policy: IPersistedChannelPolicy;
+    }>;
+    deleteChannelPolicy(channelId: string): void;
+    savePeerStorageBlob(peerPubkey: string, blob: Buffer, receivedAt: number): void;
+    loadPeerStorageBlob(peerPubkey: string): {
+        blob: Buffer;
+        receivedAt: number;
+    } | null;
+    deletePeerStorageBlob(peerPubkey: string): void;
+    saveWatchtowerSession(session: IWatchtowerSession, sessionKey: Buffer): void;
+    loadWatchtowerSessions(): Array<IWatchtowerSession & {
+        sessionKey: Buffer;
+    }>;
+    setWatchtowerSessionProgress(sessionId: string, seqNum: number, lastApplied: number): void;
+    deleteWatchtowerTower(towerUri: string): void;
+    addWatchtowerUpdate(update: IWatchtowerUpdate): number;
+    loadPendingWatchtowerUpdates(): Array<IWatchtowerUpdate & {
+        id: number;
+    }>;
+    markWatchtowerUpdateAcked(id: number, seqNum: number): void;
+    saveForwardingEvent(event: Omit<IForwardingEvent, 'id'>): void;
+    listForwardingEvents(filter?: IForwardingEventFilter): IForwardingEvent[];
+    getForwardingSummary(options?: {
+        since?: number;
+    }): IForwardingSummary;
     transaction<T>(fn: () => T): T;
     saveWebhook(id: string, url: string, events: string[], secretHash?: string, createdAt?: number): void;
     deleteWebhook(id: string): void;