beignet 0.31.0 → 0.32.0

package/dist/types/lightning/message/channel-close.d.ts

@@ -1,19 +1,72 @@
+/**
+ * BOLT 2: `shutdown`, `closing_signed`, and option_simple_close
+ * `closing_complete` / `closing_sig` message encoding/decoding.
+ *
+ * shutdown (type 38):
+ *   [32: channel_id]
+ *   [2: len]
+ *   [len: scriptpubkey]
+ *
+ * closing_signed (type 39):
+ *   [32: channel_id]
+ *   [8: fee_satoshis]
+ *   [64: signature]
+ *
+ * closing_complete (type 40) / closing_sig (type 41):
+ *   [32: channel_id]
+ *   [2: len] [len: closer_scriptpubkey]
+ *   [2: len] [len: closee_scriptpubkey]
+ *   [8: fee_satoshis]
+ *   [4: locktime]
+ *   [closing_tlvs]
+ * where closing_tlvs carries the 64-byte signature(s):
+ *   type 1: closer_output_only
+ *   type 2: closee_output_only
+ *   type 3: closer_and_closee_outputs
+ * closing_complete may carry two records (1 and 3); closing_sig must carry
+ * exactly one, matching a field the closer sent (enforced in the state
+ * machine, not the codec).
+ */
+/// <reference types="node" />
 /// <reference types="node" />
 export interface IShutdownMessage {
     channelId: Buffer;
     scriptPubkey: Buffer;
+    /**
+     * MuSig2 closing pubnonce (66 bytes) for simple-taproot channels, carried
+     * as TLV type 8 (LND shutdown_nonce convention). Absent on non-taproot
+     * channels; the wire encoding is byte-identical to legacy when unset.
+     */
     shutdownNonce?: Buffer;
 }
 export interface IClosingSignedMessage {
     channelId: Buffer;
     feeSatoshis: bigint;
     signature: Buffer;
+    /**
+     * MuSig2 partial signature (32 bytes) for simple-taproot channels, carried
+     * as TLV type 6 (LND partial_sig convention). When set, the fixed 64-byte
+     * `signature` field is zeroed on the wire.
+     */
     partialSignature?: Buffer;
 }
+/**
+ * Encode a `shutdown` message payload.
+ */
 export declare function encodeShutdownMessage(msg: IShutdownMessage): Buffer;
+/**
+ * Decode a `shutdown` message payload.
+ */
 export declare function decodeShutdownMessage(payload: Buffer): IShutdownMessage;
+/**
+ * Encode a `closing_signed` message payload.
+ */
 export declare function encodeClosingSignedMessage(msg: IClosingSignedMessage): Buffer;
+/**
+ * Decode a `closing_signed` message payload.
+ */
 export declare function decodeClosingSignedMessage(payload: Buffer): IClosingSignedMessage;
+/** closing_tlvs record types (each value is a 64-byte signature). */
 export declare enum ClosingSigVariant {
     CLOSER_OUTPUT_ONLY = 1,
     CLOSEE_OUTPUT_ONLY = 2,
@@ -25,12 +78,20 @@ export interface IClosingCompleteMessage {
     closeeScriptPubkey: Buffer;
     feeSatoshis: bigint;
     locktime: number;
+    /** Signature for a closing tx with only the closer's output (TLV 1). */
     closerOutputOnlySig?: Buffer;
+    /** Signature for a closing tx with only the closee's output (TLV 2). */
     closeeOutputOnlySig?: Buffer;
+    /** Signature for a closing tx with both outputs (TLV 3). */
     closerAndCloseeSig?: Buffer;
 }
+/** Identical wire layout; exactly-one-sig is a state-machine rule. */
 export type IClosingSigMessage = IClosingCompleteMessage;
+/** Encode a `closing_complete` (type 40) message payload. */
 export declare function encodeClosingCompleteMessage(msg: IClosingCompleteMessage): Buffer;
+/** Decode a `closing_complete` (type 40) message payload. */
 export declare function decodeClosingCompleteMessage(payload: Buffer): IClosingCompleteMessage;
+/** Encode a `closing_sig` (type 41) message payload. */
 export declare function encodeClosingSigMessage(msg: IClosingSigMessage): Buffer;
+/** Decode a `closing_sig` (type 41) message payload. */
 export declare function decodeClosingSigMessage(payload: Buffer): IClosingSigMessage;

package/dist/types/lightning/message/channel-commitment.d.ts

@@ -1,18 +1,64 @@
+/**
+ * BOLT 2: `commitment_signed` and `revoke_and_ack` message encoding/decoding.
+ *
+ * commitment_signed (type 132):
+ *   [32: channel_id]
+ *   [64: signature]
+ *   [2: num_htlcs]
+ *   [num_htlcs * 64: htlc_signature]
+ *   commitment_signed_tlvs:
+ *     type 1 (splice_info): [32: funding_txid]
+ *
+ * Splicing (lightning/bolts #1160, CLN-compatible): during a splice the sender
+ * MUST set the `funding_txid` (TLV type 1) to the funding transaction the
+ * commitment spends, so the receiver can route it to the right (old vs spliced)
+ * funding output. txid is internal byte order (tx.getHash(), CLN
+ * `towire_bitcoin_txid`).
+ *
+ * revoke_and_ack (type 133):
+ *   [32: channel_id]
+ *   [32: per_commitment_secret]
+ *   [33: next_per_commitment_point]
+ */
+/// <reference types="node" />
 /// <reference types="node" />
 export interface ICommitmentSignedMessage {
     channelId: Buffer;
     signature: Buffer;
     htlcSignatures: Buffer[];
+    /** Splice: the funding txid this commitment spends (TLV type 1, internal order). */
     fundingTxid?: Buffer;
+    /**
+     * option_taproot: the signer's 98-byte partial_signature_with_nonce (32-byte
+     * MuSig2 partial signature || 66-byte public nonce) over the recipient's
+     * commitment. Replaces the ECDSA `signature` field for taproot channels (which
+     * is then all-zero). TLV type 2 (LND convention; pin at interop).
+     */
     partialSignatureWithNonce?: Buffer;
 }
 export interface IRevokeAndAckMessage {
     channelId: Buffer;
     perCommitmentSecret: Buffer;
     nextPerCommitmentPoint: Buffer;
+    /**
+     * option_taproot: our 66-byte MuSig2 public nonce for the NEXT commitment
+     * (rotate-on-revoke). The previous nonce is now spent. TLV type 4.
+     */
     nextLocalNonce?: Buffer;
 }
+/**
+ * Encode a `commitment_signed` message payload.
+ */
 export declare function encodeCommitmentSignedMessage(msg: ICommitmentSignedMessage): Buffer;
+/**
+ * Decode a `commitment_signed` message payload.
+ */
 export declare function decodeCommitmentSignedMessage(payload: Buffer): ICommitmentSignedMessage;
+/**
+ * Encode a `revoke_and_ack` message payload.
+ */
 export declare function encodeRevokeAndAckMessage(msg: IRevokeAndAckMessage): Buffer;
+/**
+ * Decode a `revoke_and_ack` message payload.
+ */
 export declare function decodeRevokeAndAckMessage(payload: Buffer): IRevokeAndAckMessage;

package/dist/types/lightning/message/channel-funding.d.ts

@@ -1,25 +1,82 @@
+/**
+ * BOLT 2: `funding_created`, `funding_signed`, and `channel_ready` message
+ * encoding/decoding.
+ *
+ * funding_created (type 34):
+ *   [32: temporary_channel_id]
+ *   [32: funding_txid]
+ *   [2: funding_output_index]
+ *   [64: signature]
+ *
+ * funding_signed (type 35):
+ *   [32: channel_id]
+ *   [64: signature]
+ *
+ * channel_ready (type 36):
+ *   [32: channel_id]
+ *   [33: second_per_commitment_point]
+ *   [channel_ready_tlvs]
+ */
+/// <reference types="node" />
 /// <reference types="node" />
 export interface IFundingCreatedMessage {
     temporaryChannelId: Buffer;
     fundingTxid: Buffer;
     fundingOutputIndex: number;
     signature: Buffer;
+    /**
+     * option_taproot: the funder's 98-byte partial_signature_with_nonce (32-byte
+     * MuSig2 partial signature over the acceptor's initial commitment #0 || the
+     * funder's 66-byte single-use signing nonce). When present the fixed 64-byte
+     * `signature` field is all-zero. TLV type 2.
+     */
     partialSignatureWithNonce?: Buffer;
 }
 export interface IFundingSignedMessage {
     channelId: Buffer;
     signature: Buffer;
+    /**
+     * option_taproot: the acceptor's 98-byte partial_signature_with_nonce (32-byte
+     * MuSig2 partial signature over the funder's initial commitment #0 || the
+     * acceptor's 66-byte single-use signing nonce). When present the fixed 64-byte
+     * `signature` field is all-zero. TLV type 2.
+     */
     partialSignatureWithNonce?: Buffer;
 }
 export interface IChannelReadyMessage {
     channelId: Buffer;
     secondPerCommitmentPoint: Buffer;
     shortChannelId?: Buffer;
+    /**
+     * option_taproot: our 66-byte MuSig2 verification nonce for commitment #1 — the
+     * bootstrap of the verification-nonce pipeline, mirroring how
+     * second_per_commitment_point seeds the per-commitment-point pipeline. The peer
+     * uses this to co-sign our first post-funding commitment. TLV type 4 (matches
+     * the open/accept/revoke next_local_nonce convention; pin at interop).
+     */
     nextLocalNonce?: Buffer;
 }
+/**
+ * Encode a `funding_created` message payload.
+ */
 export declare function encodeFundingCreatedMessage(msg: IFundingCreatedMessage): Buffer;
+/**
+ * Decode a `funding_created` message payload.
+ */
 export declare function decodeFundingCreatedMessage(payload: Buffer): IFundingCreatedMessage;
+/**
+ * Encode a `funding_signed` message payload.
+ */
 export declare function encodeFundingSignedMessage(msg: IFundingSignedMessage): Buffer;
+/**
+ * Decode a `funding_signed` message payload.
+ */
 export declare function decodeFundingSignedMessage(payload: Buffer): IFundingSignedMessage;
+/**
+ * Encode a `channel_ready` message payload.
+ */
 export declare function encodeChannelReadyMessage(msg: IChannelReadyMessage): Buffer;
+/**
+ * Decode a `channel_ready` message payload.
+ */
 export declare function decodeChannelReadyMessage(payload: Buffer): IChannelReadyMessage;

package/dist/types/lightning/message/channel-open.d.ts

@@ -1,3 +1,45 @@
+/**
+ * BOLT 2: `open_channel` and `accept_channel` message encoding/decoding.
+ *
+ * open_channel (type 32):
+ *   [32: chain_hash]
+ *   [32: temporary_channel_id]
+ *   [8: funding_satoshis]
+ *   [8: push_msat]
+ *   [8: dust_limit_satoshis]
+ *   [8: max_htlc_value_in_flight_msat]
+ *   [8: channel_reserve_satoshis]
+ *   [8: htlc_minimum_msat]
+ *   [4: feerate_per_kw]
+ *   [2: to_self_delay]
+ *   [2: max_accepted_htlcs]
+ *   [33: funding_pubkey]
+ *   [33: revocation_basepoint]
+ *   [33: payment_basepoint]
+ *   [33: delayed_payment_basepoint]
+ *   [33: htlc_basepoint]
+ *   [33: first_per_commitment_point]
+ *   [1: channel_flags]
+ *   [open_channel_tlvs]
+ *
+ * accept_channel (type 33):
+ *   [32: temporary_channel_id]
+ *   [8: dust_limit_satoshis]
+ *   [8: max_htlc_value_in_flight_msat]
+ *   [8: channel_reserve_satoshis]
+ *   [8: htlc_minimum_msat]
+ *   [4: minimum_depth]
+ *   [2: to_self_delay]
+ *   [2: max_accepted_htlcs]
+ *   [33: funding_pubkey]
+ *   [33: revocation_basepoint]
+ *   [33: payment_basepoint]
+ *   [33: delayed_payment_basepoint]
+ *   [33: htlc_basepoint]
+ *   [33: first_per_commitment_point]
+ *   [accept_channel_tlvs]
+ */
+/// <reference types="node" />
 /// <reference types="node" />
 export interface IOpenChannelMessage {
     chainHash: Buffer;
@@ -20,6 +62,7 @@ export interface IOpenChannelMessage {
     channelFlags: number;
     upfrontShutdownScript?: Buffer;
     channelType?: Buffer;
+    /** option_taproot: 66-byte MuSig2 public nonce for the first commitment. */
     nextLocalNonce?: Buffer;
 }
 export interface IAcceptChannelMessage {
@@ -39,9 +82,22 @@ export interface IAcceptChannelMessage {
     firstPerCommitmentPoint: Buffer;
     upfrontShutdownScript?: Buffer;
     channelType?: Buffer;
+    /** option_taproot: 66-byte MuSig2 public nonce for the first commitment. */
     nextLocalNonce?: Buffer;
 }
+/**
+ * Encode an `open_channel` message payload (without 2-byte type prefix).
+ */
 export declare function encodeOpenChannelMessage(msg: IOpenChannelMessage): Buffer;
+/**
+ * Decode an `open_channel` message payload.
+ */
 export declare function decodeOpenChannelMessage(payload: Buffer): IOpenChannelMessage;
+/**
+ * Encode an `accept_channel` message payload (without 2-byte type prefix).
+ */
 export declare function encodeAcceptChannelMessage(msg: IAcceptChannelMessage): Buffer;
+/**
+ * Decode an `accept_channel` message payload.
+ */
 export declare function decodeAcceptChannelMessage(payload: Buffer): IAcceptChannelMessage;

package/dist/types/lightning/message/channel-reestablish.d.ts

@@ -1,15 +1,56 @@
+/**
+ * BOLT 2: `channel_reestablish` message encoding/decoding.
+ *
+ * channel_reestablish (type 136):
+ *   [32: channel_id]
+ *   [8: next_commitment_number]
+ *   [8: next_revocation_number]
+ *   [32: your_last_per_commitment_secret]
+ *   [33: my_current_per_commitment_point]
+ *   TLV stream:
+ *     type 1 (next_funding): [32: next_funding_txid][1: retransmit_flags] —
+ *     txid of an in-flight interactive (splice) funding tx, in tx.getHash()
+ *     internal byte order (same convention as tx_signatures.txid). Set when we
+ *     sent commitment_signed for the new funding tx but have not received the
+ *     peer's tx_signatures. Flags bit 0 = "retransmit your commitment_signed".
+ *     (Decode also accepts legacy type 0 = bare 32-byte txid.)
+ */
 /// <reference types="node" />
-import { IFforReestablishTlv } from '../ffor/types';
+/// <reference types="node" />
+import type { IFforReestablishTlv } from '../ffor/types';
 export interface IChannelReestablishMessage {
     channelId: Buffer;
     nextCommitmentNumber: bigint;
     nextRevocationNumber: bigint;
     yourLastPerCommitmentSecret: Buffer;
     myCurrentPerCommitmentPoint: Buffer;
+    /** Splice resumption (merged splice spec): txid of the in-flight funding tx. */
     nextFundingTxid?: Buffer;
+    /**
+     * CLN v25.12+ appends a retransmit-flags byte to the next_funding TLV
+     * (bit 0: peer asks us to retransmit commitment_signed). Absent on peers
+     * using the original 32-byte TLV.
+     */
     nextFundingRetransmitFlags?: number;
+    /**
+     * option_taproot: a freshly-generated MuSig2 verification public nonce (66
+     * bytes) re-seeding the peer for the next commitment. The in-memory nonces are
+     * lost on reconnect, so both sides regenerate and re-exchange them here (LND
+     * local_nonce, TLV type 4 — same convention as open/accept/revoke).
+     */
     nextLocalNonce?: Buffer;
+    /**
+     * FFOR (docs/specs/ffor-offline-receive.md section 11.1): TLV 55001, the
+     * epoch id, lifecycle state, last_seq and H_act of the channel's epoch.
+     * Odd, so a peer without the feature ignores it.
+     */
     ffor?: IFforReestablishTlv;
 }
+/**
+ * Encode a `channel_reestablish` message payload.
+ */
 export declare function encodeChannelReestablishMessage(msg: IChannelReestablishMessage): Buffer;
+/**
+ * Decode a `channel_reestablish` message payload.
+ */
 export declare function decodeChannelReestablishMessage(payload: Buffer): IChannelReestablishMessage;

package/dist/types/lightning/message/channel-update.d.ts

@@ -1,3 +1,36 @@
+/**
+ * BOLT 2: HTLC and fee update message encoding/decoding.
+ *
+ * update_add_htlc (type 128):
+ *   [32: channel_id]
+ *   [8: id]
+ *   [8: amount_msat]
+ *   [32: payment_hash]
+ *   [4: cltv_expiry]
+ *   [1366: onion_routing_packet]
+ *
+ * update_fulfill_htlc (type 130):
+ *   [32: channel_id]
+ *   [8: id]
+ *   [32: payment_preimage]
+ *
+ * update_fail_htlc (type 131):
+ *   [32: channel_id]
+ *   [8: id]
+ *   [2: len]
+ *   [len: reason]
+ *
+ * update_fail_malformed_htlc (type 135):
+ *   [32: channel_id]
+ *   [8: id]
+ *   [32: sha256_of_onion]
+ *   [2: failure_code]
+ *
+ * update_fee (type 134):
+ *   [32: channel_id]
+ *   [4: feerate_per_kw]
+ */
+/// <reference types="node" />
 /// <reference types="node" />
 export interface IUpdateAddHtlcMessage {
     channelId: Buffer;
@@ -6,6 +39,11 @@ export interface IUpdateAddHtlcMessage {
     paymentHash: Buffer;
     cltvExpiry: number;
     onionRoutingPacket: Buffer;
+    /**
+     * Route blinding (BOLT 2/4): blinding_point TLV (type 0). Set by the
+     * introduction node when forwarding into a blinded path so the next blinded
+     * hop can derive its blinded node key. 33-byte compressed point.
+     */
     blindingPoint?: Buffer;
 }
 export interface IUpdateFulfillHtlcMessage {
@@ -28,19 +66,60 @@ export interface IUpdateFeeMessage {
     channelId: Buffer;
     feeratePerKw: number;
 }
+/**
+ * bLIP-0051 / CLN `update_blockheight` (type 137): on a leased channel the
+ * OPENER advances the blockheight both sides agreed on at open, shrinking the
+ * lessor's remaining-lease CSV (lease_csv = lease_expiry - blockheight).
+ */
 export interface IUpdateBlockheightMessage {
     channelId: Buffer;
     blockheight: number;
 }
+/**
+ * Encode an `update_add_htlc` message payload.
+ */
 export declare function encodeUpdateAddHtlcMessage(msg: IUpdateAddHtlcMessage): Buffer;
+/**
+ * Decode an `update_add_htlc` message payload.
+ */
 export declare function decodeUpdateAddHtlcMessage(payload: Buffer): IUpdateAddHtlcMessage;
+/**
+ * Encode an `update_fulfill_htlc` message payload.
+ */
 export declare function encodeUpdateFulfillHtlcMessage(msg: IUpdateFulfillHtlcMessage): Buffer;
+/**
+ * Decode an `update_fulfill_htlc` message payload.
+ */
 export declare function decodeUpdateFulfillHtlcMessage(payload: Buffer): IUpdateFulfillHtlcMessage;
+/**
+ * Encode an `update_fail_htlc` message payload.
+ */
 export declare function encodeUpdateFailHtlcMessage(msg: IUpdateFailHtlcMessage): Buffer;
+/**
+ * Decode an `update_fail_htlc` message payload.
+ */
 export declare function decodeUpdateFailHtlcMessage(payload: Buffer): IUpdateFailHtlcMessage;
+/**
+ * Encode an `update_fail_malformed_htlc` message payload.
+ */
 export declare function encodeUpdateFailMalformedHtlcMessage(msg: IUpdateFailMalformedHtlcMessage): Buffer;
+/**
+ * Decode an `update_fail_malformed_htlc` message payload.
+ */
 export declare function decodeUpdateFailMalformedHtlcMessage(payload: Buffer): IUpdateFailMalformedHtlcMessage;
+/**
+ * Encode an `update_fee` message payload.
+ */
 export declare function encodeUpdateFeeMessage(msg: IUpdateFeeMessage): Buffer;
+/**
+ * Decode an `update_fee` message payload.
+ */
 export declare function decodeUpdateFeeMessage(payload: Buffer): IUpdateFeeMessage;
+/**
+ * Encode an `update_blockheight` message payload (bLIP-0051, type 137).
+ */
 export declare function encodeUpdateBlockheightMessage(msg: IUpdateBlockheightMessage): Buffer;
+/**
+ * Decode an `update_blockheight` message payload (bLIP-0051, type 137).
+ */
 export declare function decodeUpdateBlockheightMessage(payload: Buffer): IUpdateBlockheightMessage;

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

@@ -1,17 +1,72 @@
+/**
+ * BOLT 1: BigSize encoding/decoding and Lightning message framing.
+ *
+ * BigSize is a variable-length unsigned integer encoding used throughout
+ * the Lightning protocol. It is similar to Bitcoin's CompactSize but
+ * uses big-endian byte order.
+ *
+ * Encoding:
+ *   0x00..0xfc        -> 1 byte (value itself)
+ *   0xfd..0xffff      -> 3 bytes (0xfd prefix + 2-byte BE value)
+ *   0x10000..0xffffffff -> 5 bytes (0xfe prefix + 4-byte BE value)
+ *   0x100000000+       -> 9 bytes (0xff prefix + 8-byte BE value)
+ */
 /// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Encode a number as a BigSize variable-length integer.
+ * @param value - Non-negative integer to encode
+ * @returns Buffer containing the BigSize encoding
+ */
 export declare function encodeBigSize(value: bigint): Buffer;
+/**
+ * Result of decoding a BigSize value, including how many bytes were consumed.
+ */
 export interface IBigSizeResult {
     value: bigint;
     bytesRead: number;
 }
+/**
+ * Decode a BigSize variable-length integer from a buffer.
+ * @param data - Buffer to read from
+ * @param offset - Starting offset in the buffer
+ * @returns Decoded value and number of bytes consumed
+ */
 export declare function decodeBigSize(data: Buffer, offset?: number): IBigSizeResult;
+/**
+ * Decode a BigSize into two unsigned 32-bit halves without allocating a
+ * BigInt: value = out.hi * 2^32 + out.lo. Same bounds checks and error
+ * messages as decodeBigSize (a non-canonical value is always below 2^32, so
+ * it prints the same digits), for hot loops such as the Rapid Gossip Sync
+ * import, where a BigInt per field dominated the cost.
+ * @param data - Buffer to read from
+ * @param offset - Starting offset in the buffer
+ * @param out - Receives the decoded halves
+ * @returns Number of bytes consumed
+ */
 export declare function readBigSizeParts(data: Buffer, offset: number, out: {
     hi: number;
     lo: number;
 }): number;
+/**
+ * Encode a Lightning message with the standard framing format.
+ * Format: [2-byte type (BE)][payload]
+ * @param type - Message type ID (0-65535)
+ * @param payload - Message payload
+ * @returns Framed message buffer
+ */
 export declare function encodeMessage(type: number, payload: Buffer): Buffer;
+/**
+ * Decoded Lightning message.
+ */
 export interface IDecodedMessage {
     type: number;
     payload: Buffer;
 }
+/**
+ * Decode a Lightning message from a buffer.
+ * Format: [2-byte type (BE)][payload]
+ * @param data - Raw message bytes
+ * @returns Decoded message type and payload
+ */
 export declare function decodeMessage(data: Buffer): IDecodedMessage;

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

@@ -1,31 +1,91 @@
+/**
+ * Beignet-to-beignet custom peer messaging (issue #546, LFBW port #532
+ * workstream 1E).
+ *
+ * Everything rides on ONE odd wire type in the BOLT 1 custom range
+ * (>= 32768), so "it's OK to be odd" applies: LND, CLN, eclair and older
+ * beignet peers silently ignore it, making every protocol built on top
+ * fallback-safe by construction. Envelope layout:
+ *
+ *   [u16 protocolVersion][u16 subtype][payload...]
+ *
+ * Receivers must ignore unknown subtypes and versions (the node surfaces
+ * them on the 'custom-message' event and refuses nothing); a payload that
+ * fails to decode is logged and dropped without disconnecting the peer.
+ */
 /// <reference types="node" />
+/// <reference types="node" />
+/** Single odd message type carrying all beignet custom traffic. */
 export declare const BEIGNET_CUSTOM_MESSAGE_TYPE = 44069;
 export declare const BEIGNET_CUSTOM_PROTOCOL_VERSION = 1;
+/**
+ * Largest application payload one envelope can carry: BOLT 8 caps a Lightning
+ * message at 65535 bytes, of which the wire type takes 2 and this envelope's
+ * header 4. Enforced at encode so an oversized payload fails HERE, named,
+ * instead of deep in the transport cipher after the caller thinks it sent
+ * (issue #546 review).
+ */
 export declare const BEIGNET_CUSTOM_MAX_PAYLOAD: number;
+/**
+ * Subtype registry. The numbers are RESERVED here ahead of the workstreams
+ * that implement them (#532 phases 3 and 4) so no later protocol collides:
+ * 1, 2, 4 and 5 belong to JIT receive, 16 to 22 to direct funding, and 32
+ * to 47 to recovery guardian sessions (issue #699), 48 to 55 to the
+ * swap provider (issue #737), and 64 to 65 to splice conflict recovery
+ * (issue #760), and 80 to 81 to automatic offline receiving. 3 (LIQUIDITY_POLICY) and 20
+ * (DIRECT_FUNDING_ABORT) are numbers the LFBW fork declared but never used;
+ * they stay reserved and deliberately unimplemented.
+ */
 export declare enum BeignetCustomSubtype {
     JIT_RECEIVE_AUTHORIZATION = 1,
     JIT_RECEIVE_ACK = 2,
+    /** Reserved, never implemented. */
     LIQUIDITY_POLICY = 3,
+    /** A wallet asks what a JIT receive would cost and whether the LSP would
+     *  serve it right now; registers nothing on the LSP (issue #687). */
     JIT_RECEIVE_QUOTE = 4,
     JIT_RECEIVE_QUOTE_ACK = 5,
     DIRECT_FUNDING_OFFER = 16,
     DIRECT_FUNDING_OFFER_ACK = 17,
     DIRECT_FUNDING_SIGN_REQUEST = 18,
     DIRECT_FUNDING_WITNESS = 19,
+    /** Reserved, never implemented. */
     DIRECT_FUNDING_ABORT = 20,
+    /** Receiver to sender after broadcast: reveals the preimage of the
+     *  receipt hash the sender's offer carried, a provable delivery
+     *  receipt. */
     DIRECT_FUNDING_RECEIPT = 21,
+    /** Blind relay envelope: {to, t, p} from a sender, forwarded by the LSP
+     *  to a connected peer as {from, t, p} with `from` stamped by the LSP
+     *  itself, so neither party can spoof the other. Payloads are sealed to
+     *  the request key; the relay reads nothing. */
     DIRECT_FUNDING_RELAY = 22,
+    /** One chunk of a guardian verb request over a bolt8 guardian session
+     *  (docs/RECOVERY-GUARDIAN-WIRE.md 2.7; recovery/guardian-bolt8.ts). */
     GUARDIAN_REQUEST = 32,
+    /** One chunk of the guardian's response to a GUARDIAN_REQUEST. */
     GUARDIAN_RESPONSE = 33,
+    /** A client asks what a swap of a given direction and size would cost;
+     *  registers nothing on the provider. */
     SWAP_QUOTE_REQUEST = 48,
     SWAP_QUOTE = 49,
+    /** A client opens a swap: for a reverse swap it names the payment hash
+     *  it holds the preimage of, its claim key and the on-chain amount. */
     SWAP_CREATE = 50,
+    /** The provider's terms (hold invoice, refund key and height, contract
+     *  address) or a typed refusal. */
     SWAP_CREATE_ACK = 51,
     SWAP_STATUS_REQUEST = 52,
     SWAP_STATUS = 53,
+    /** Submarine direction (issue #743): the client funds, the provider pays. */
     SWAP_SUBMARINE_CREATE = 54,
     SWAP_SUBMARINE_CREATE_ACK = 55,
+    /** An input of an in-flight splice was spent elsewhere and the spend
+     *  confirmed: the sender asks the peer to verify on its own chain view
+     *  and revert to the pre-splice funding (message/splice-conflict.ts). */
     SPLICE_CONFLICT = 64,
+    /** The peer's answer: agreed (it verified and reverted) or not, with a
+     *  reason. */
     SPLICE_CONFLICT_ACK = 65,
     FFOR_RECEIVE_REQUEST = 80,
     FFOR_RECEIVE_RESPONSE = 81