@t402/btc 2.7.0

package/dist/cjs/index.js

@@ -0,0 +1,849 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ALL_NETWORKS: () => ALL_NETWORKS,
+  BTC_MAINNET: () => BTC_MAINNET,
+  BTC_NETWORKS: () => BTC_NETWORKS,
+  BTC_TESTNET: () => BTC_TESTNET,
+  DEFAULT_VALIDITY_DURATION: () => DEFAULT_VALIDITY_DURATION,
+  DUST_LIMIT: () => DUST_LIMIT,
+  ExactBtcScheme: () => ExactBtcScheme,
+  LIGHTNING_MAINNET: () => LIGHTNING_MAINNET,
+  LIGHTNING_NETWORKS: () => LIGHTNING_NETWORKS,
+  LIGHTNING_TESTNET: () => LIGHTNING_TESTNET,
+  LightningScheme: () => LightningScheme,
+  MAINNET_ADDRESS_PREFIXES: () => MAINNET_ADDRESS_PREFIXES,
+  MIN_RELAY_FEE: () => MIN_RELAY_FEE,
+  SATS_PER_BTC: () => SATS_PER_BTC,
+  SCHEME_EXACT: () => SCHEME_EXACT,
+  TESTNET_ADDRESS_PREFIXES: () => TESTNET_ADDRESS_PREFIXES,
+  btcToSatoshis: () => btcToSatoshis,
+  isMainnetAddress: () => isMainnetAddress,
+  isTestnetAddress: () => isTestnetAddress,
+  isValidHex: () => isValidHex,
+  registerExactBtcClientScheme: () => registerExactBtcScheme,
+  registerExactBtcFacilitatorScheme: () => registerExactBtcScheme3,
+  registerExactBtcServerScheme: () => registerExactBtcScheme2,
+  registerLightningClientScheme: () => registerLightningScheme,
+  registerLightningFacilitatorScheme: () => registerLightningScheme3,
+  registerLightningServerScheme: () => registerLightningScheme2,
+  satoshisToBtc: () => satoshisToBtc,
+  validateBitcoinAddress: () => validateBitcoinAddress,
+  validateBolt11Invoice: () => validateBolt11Invoice
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var BTC_MAINNET = "bip122:000000000019d6689c085ae165831e93";
+var BTC_TESTNET = "bip122:000000000933ea01ad0ee984209779ba";
+var LIGHTNING_MAINNET = "lightning:mainnet";
+var LIGHTNING_TESTNET = "lightning:testnet";
+var BTC_NETWORKS = [BTC_MAINNET, BTC_TESTNET];
+var LIGHTNING_NETWORKS = [LIGHTNING_MAINNET, LIGHTNING_TESTNET];
+var ALL_NETWORKS = [...BTC_NETWORKS, ...LIGHTNING_NETWORKS];
+var DUST_LIMIT = 546;
+var MIN_RELAY_FEE = 1e3;
+var SATS_PER_BTC = 1e8;
+var SCHEME_EXACT = "exact";
+var DEFAULT_VALIDITY_DURATION = 3600;
+var MAINNET_ADDRESS_PREFIXES = ["bc1", "1", "3"];
+var TESTNET_ADDRESS_PREFIXES = ["tb1", "m", "n", "2"];
+
+// src/utils.ts
+function satoshisToBtc(sats) {
+  const satsBigInt = BigInt(sats);
+  const whole = satsBigInt / BigInt(SATS_PER_BTC);
+  const frac = satsBigInt % BigInt(SATS_PER_BTC);
+  if (frac === 0n) {
+    return whole.toString();
+  }
+  const fracStr = frac.toString().padStart(8, "0");
+  return `${whole}.${fracStr}`.replace(/\.?0+$/, "");
+}
+function btcToSatoshis(btc) {
+  const btcStr = typeof btc === "number" ? btc.toString() : btc;
+  const [wholePart, fracPart = ""] = btcStr.split(".");
+  const paddedFrac = fracPart.padEnd(8, "0").slice(0, 8);
+  const combined = wholePart + paddedFrac;
+  const result = BigInt(combined.replace(/^0+/, "") || "0");
+  return result;
+}
+function validateBitcoinAddress(address) {
+  if (!address || address.length < 14 || address.length > 90) {
+    return false;
+  }
+  const allPrefixes = [...MAINNET_ADDRESS_PREFIXES, ...TESTNET_ADDRESS_PREFIXES];
+  return allPrefixes.some((prefix) => address.startsWith(prefix));
+}
+function isMainnetAddress(address) {
+  return MAINNET_ADDRESS_PREFIXES.some((prefix) => address.startsWith(prefix));
+}
+function isTestnetAddress(address) {
+  return TESTNET_ADDRESS_PREFIXES.some((prefix) => address.startsWith(prefix));
+}
+function validateBolt11Invoice(invoice) {
+  if (!invoice || invoice.length < 20) {
+    return false;
+  }
+  const lower = invoice.toLowerCase();
+  return lower.startsWith("lnbc") || lower.startsWith("lntb") || lower.startsWith("lnbcrt");
+}
+function isValidHex(hex, expectedLength) {
+  if (!/^[0-9a-fA-F]+$/.test(hex)) {
+    return false;
+  }
+  if (expectedLength !== void 0 && hex.length !== expectedLength * 2) {
+    return false;
+  }
+  return true;
+}
+
+// src/exact/client/scheme.ts
+var ExactBtcScheme = class {
+  /**
+   * Creates a new ExactBtcScheme instance.
+   *
+   * @param signer - The Bitcoin signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_EXACT);
+  }
+  /**
+   * Creates a payment payload for the Exact scheme.
+   *
+   * The payload contains a signed PSBT with a single output
+   * paying the required amount to the payTo address.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    if (!paymentRequirements.payTo) {
+      throw new Error("PayTo address is required");
+    }
+    if (!paymentRequirements.amount) {
+      throw new Error("Amount is required");
+    }
+    if (!validateBitcoinAddress(paymentRequirements.payTo)) {
+      throw new Error(`Invalid Bitcoin address: ${paymentRequirements.payTo}`);
+    }
+    const amountSats = BigInt(paymentRequirements.amount);
+    if (amountSats < BigInt(DUST_LIMIT)) {
+      throw new Error(`Amount ${amountSats} satoshis is below dust limit (${DUST_LIMIT})`);
+    }
+    const unsignedPsbt = this.buildUnsignedPsbt(paymentRequirements);
+    const signedPsbt = await this.signer.signPsbt(unsignedPsbt);
+    const payload = {
+      signedPsbt
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Build an unsigned PSBT for the payment.
+   *
+   * Creates a minimal PSBT representation with the required output.
+   * The actual UTXO selection and fee calculation should be handled
+   * by the signer implementation (which typically has wallet context).
+   *
+   * @param requirements - Payment requirements
+   * @returns Base64-encoded unsigned PSBT
+   */
+  buildUnsignedPsbt(requirements) {
+    const psbtData = {
+      outputs: [
+        {
+          address: requirements.payTo,
+          value: requirements.amount
+        }
+      ],
+      network: requirements.network,
+      fromAddress: this.signer.getAddress(),
+      fromPubKey: this.signer.getPublicKey()
+    };
+    return Buffer.from(JSON.stringify(psbtData)).toString("base64");
+  }
+};
+
+// src/exact/client/register.ts
+function registerExactBtcScheme(client, config) {
+  const scheme = new ExactBtcScheme(config.signer);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("bip122:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/lightning/client/scheme.ts
+var LightningScheme = class {
+  /**
+   * Creates a new LightningScheme instance.
+   *
+   * @param signer - The Lightning signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_EXACT);
+  }
+  /**
+   * Creates a payment payload for the Lightning scheme.
+   *
+   * 1. Extracts the BOLT11 invoice from requirements.extra.bolt11Invoice
+   * 2. Pays the invoice using the Lightning signer
+   * 3. Returns the preimage and payment hash as proof of payment
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    const bolt11Invoice = paymentRequirements.extra?.bolt11Invoice;
+    if (!bolt11Invoice) {
+      throw new Error("BOLT11 invoice is required in requirements.extra.bolt11Invoice");
+    }
+    if (!validateBolt11Invoice(bolt11Invoice)) {
+      throw new Error(`Invalid BOLT11 invoice format: ${bolt11Invoice.slice(0, 20)}...`);
+    }
+    const { preimage, paymentHash } = await this.signer.payInvoice(bolt11Invoice);
+    const payload = {
+      paymentHash,
+      preimage,
+      bolt11Invoice
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+};
+
+// src/lightning/client/register.ts
+function registerLightningScheme(client, config) {
+  const scheme = new LightningScheme(config.signer);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("lightning:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/exact/server/scheme.ts
+var ExactBtcScheme2 = class {
+  constructor(config) {
+    __publicField(this, "scheme", SCHEME_EXACT);
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount in satoshis.
+   *
+   * Accepts:
+   * - Number: treated as USD, converted to satoshis at a default rate
+   * - String with $: treated as USD
+   * - AssetAmount: returned directly
+   *
+   * For Bitcoin, amounts are always in satoshis and the asset is "BTC".
+   *
+   * @param price - The price to parse
+   * @param network - The network to use
+   * @returns Promise that resolves to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount);
+  }
+  /**
+   * Build payment requirements for this scheme/network combination.
+   *
+   * @param paymentRequirements - Base payment requirements with amount/asset already set
+   * @param supportedKind - The supported kind from facilitator
+   * @param extensionKeys - Extensions supported by the facilitator
+   * @returns Enhanced payment requirements
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void supportedKind;
+    void extensionKeys;
+    return {
+      ...paymentRequirements,
+      payTo: paymentRequirements.payTo || this.config.payTo,
+      asset: paymentRequirements.asset || "BTC"
+    };
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      if (!Number.isFinite(money)) {
+        throw new Error(`Invalid money value: ${money}`);
+      }
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Default money conversion: treat amount as satoshis.
+   * For direct satoshi amounts, the amount is used as-is.
+   */
+  defaultMoneyConversion(amount) {
+    const sats = Math.floor(amount * SATS_PER_BTC);
+    return {
+      amount: sats.toString(),
+      asset: "BTC",
+      extra: {
+        symbol: "BTC",
+        decimals: 8
+      }
+    };
+  }
+};
+
+// src/exact/server/register.ts
+function registerExactBtcScheme2(server, config) {
+  const scheme = new ExactBtcScheme2(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("bip122:*", scheme);
+  }
+  return server;
+}
+
+// src/exact/facilitator/scheme.ts
+var ExactBtcScheme3 = class {
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_EXACT);
+    __publicField(this, "caipFamily", "bip122:*");
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   * Bitcoin on-chain has no extra data.
+   */
+  getExtra(_network) {
+    return void 0;
+  }
+  /**
+   * Get signer addresses used by this facilitator.
+   */
+  getSigners(_network) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload.
+   *
+   * Validates:
+   * 1. Scheme and network matching
+   * 2. PSBT structure and signatures
+   * 3. Output matches (payTo, amount)
+   * 4. Amount above dust limit
+   */
+  async verify(payload, requirements) {
+    const btcPayload = payload.payload;
+    if (!btcPayload?.signedPsbt) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.scheme !== SCHEME_EXACT || requirements.scheme !== SCHEME_EXACT) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: void 0
+      };
+    }
+    const validNetworks = BTC_NETWORKS;
+    if (!validNetworks.includes(requirements.network)) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_network",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: void 0
+      };
+    }
+    if (!validateBitcoinAddress(requirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_pay_to_address",
+        payer: void 0
+      };
+    }
+    if (BigInt(requirements.amount) < BigInt(DUST_LIMIT)) {
+      return {
+        isValid: false,
+        invalidReason: "amount_below_dust_limit",
+        payer: void 0
+      };
+    }
+    try {
+      const result = await this.signer.verifyPsbt({
+        signedPsbt: btcPayload.signedPsbt,
+        expectedPayTo: requirements.payTo,
+        expectedAmount: requirements.amount
+      });
+      if (!result.valid) {
+        return {
+          isValid: false,
+          invalidReason: result.reason || "psbt_verification_failed",
+          payer: result.payer
+        };
+      }
+      return {
+        isValid: true,
+        invalidReason: void 0,
+        payer: result.payer
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        isValid: false,
+        invalidReason: `verification_error: ${errorMessage}`,
+        payer: void 0
+      };
+    }
+  }
+  /**
+   * Settles a payment by finalizing and broadcasting the PSBT.
+   */
+  async settle(payload, requirements) {
+    const btcPayload = payload.payload;
+    if (!btcPayload?.signedPsbt) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: verifyResult.invalidReason ?? "verification_failed",
+        payer: verifyResult.payer
+      };
+    }
+    try {
+      const txId = await this.signer.broadcastPsbt(btcPayload.signedPsbt);
+      const confirmation = await this.signer.waitForConfirmation(txId, 1);
+      if (!confirmation.confirmed) {
+        return {
+          success: false,
+          errorReason: "transaction_not_confirmed",
+          transaction: txId,
+          network: payload.accepted.network,
+          payer: verifyResult.payer
+        };
+      }
+      return {
+        success: true,
+        transaction: txId,
+        network: payload.accepted.network,
+        payer: verifyResult.payer
+      };
+    } catch (error) {
+      console.error("Failed to settle Bitcoin transaction:", error);
+      return {
+        success: false,
+        errorReason: "transaction_failed",
+        transaction: "",
+        network: payload.accepted.network,
+        payer: verifyResult.payer
+      };
+    }
+  }
+};
+
+// src/exact/facilitator/register.ts
+function registerExactBtcScheme3(facilitator, config) {
+  facilitator.register(config.networks, new ExactBtcScheme3(config.signer));
+  return facilitator;
+}
+
+// src/lightning/server/scheme.ts
+var LightningScheme2 = class {
+  constructor(config) {
+    __publicField(this, "scheme", SCHEME_EXACT);
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount in satoshis.
+   *
+   * @param price - The price to parse
+   * @param network - The network to use
+   * @returns Promise that resolves to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount);
+  }
+  /**
+   * Build payment requirements for Lightning Network.
+   *
+   * Generates a BOLT11 invoice and adds it to the extra field.
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const extra = { ...paymentRequirements.extra };
+    const invoice = await this.config.generateInvoice(
+      paymentRequirements.amount,
+      `t402 payment on ${supportedKind.network}`,
+      paymentRequirements.maxTimeoutSeconds
+    );
+    extra.bolt11Invoice = invoice.bolt11Invoice;
+    extra.paymentHash = invoice.paymentHash;
+    return {
+      ...paymentRequirements,
+      asset: paymentRequirements.asset || "BTC",
+      extra
+    };
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      if (!Number.isFinite(money)) {
+        throw new Error(`Invalid money value: ${money}`);
+      }
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Default money conversion: treat amount as BTC, convert to satoshis.
+   */
+  defaultMoneyConversion(amount) {
+    const sats = Math.floor(amount * SATS_PER_BTC);
+    return {
+      amount: sats.toString(),
+      asset: "BTC",
+      extra: {
+        symbol: "BTC",
+        decimals: 8
+      }
+    };
+  }
+};
+
+// src/lightning/server/register.ts
+function registerLightningScheme2(server, config) {
+  const scheme = new LightningScheme2(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("lightning:*", scheme);
+  }
+  return server;
+}
+
+// src/lightning/facilitator/scheme.ts
+async function sha256Hex(preimageHex) {
+  const bytes = new Uint8Array(preimageHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+  const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var LightningScheme3 = class {
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_EXACT);
+    __publicField(this, "caipFamily", "lightning:*");
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   * Lightning has no extra data.
+   */
+  getExtra(_network) {
+    return void 0;
+  }
+  /**
+   * Get signer addresses (node public keys) for this facilitator.
+   */
+  getSigners(_network) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a Lightning payment payload.
+   *
+   * Validates:
+   * 1. Payload structure (paymentHash, preimage, bolt11Invoice)
+   * 2. Preimage verification: SHA-256(preimage) === paymentHash
+   * 3. Payment lookup on the Lightning node
+   */
+  async verify(payload, requirements) {
+    const lnPayload = payload.payload;
+    if (!lnPayload?.paymentHash || !lnPayload?.preimage || !lnPayload?.bolt11Invoice) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.scheme !== SCHEME_EXACT || requirements.scheme !== SCHEME_EXACT) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: void 0
+      };
+    }
+    const validNetworks = LIGHTNING_NETWORKS;
+    if (!validNetworks.includes(requirements.network)) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_network",
+        payer: void 0
+      };
+    }
+    if (!isValidHex(lnPayload.preimage, 32)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_preimage_format",
+        payer: void 0
+      };
+    }
+    if (!isValidHex(lnPayload.paymentHash, 32)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payment_hash_format",
+        payer: void 0
+      };
+    }
+    try {
+      const computedHash = await sha256Hex(lnPayload.preimage);
+      if (computedHash !== lnPayload.paymentHash.toLowerCase()) {
+        return {
+          isValid: false,
+          invalidReason: "preimage_hash_mismatch",
+          payer: void 0
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "preimage_verification_failed",
+        payer: void 0
+      };
+    }
+    try {
+      const payment = await this.signer.lookupPayment(lnPayload.paymentHash);
+      if (!payment.settled) {
+        return {
+          isValid: false,
+          invalidReason: "payment_not_settled",
+          payer: void 0
+        };
+      }
+      if (payment.amountSats && BigInt(payment.amountSats) < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_amount",
+          payer: void 0
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify payment with Lightning node:", error);
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: void 0
+    };
+  }
+  /**
+   * Settles a Lightning payment.
+   *
+   * Lightning payments are atomic (settle-on-pay), so this is effectively
+   * a confirmation that the payment was already completed. The actual
+   * settlement happened when the client paid the invoice.
+   */
+  async settle(payload, requirements) {
+    const lnPayload = payload.payload;
+    if (!lnPayload?.paymentHash || !lnPayload?.preimage) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: verifyResult.invalidReason ?? "verification_failed",
+        payer: void 0
+      };
+    }
+    return {
+      success: true,
+      transaction: lnPayload.paymentHash,
+      network: payload.accepted.network,
+      payer: void 0
+    };
+  }
+};
+
+// src/lightning/facilitator/register.ts
+function registerLightningScheme3(facilitator, config) {
+  facilitator.register(config.networks, new LightningScheme3(config.signer));
+  return facilitator;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_NETWORKS,
+  BTC_MAINNET,
+  BTC_NETWORKS,
+  BTC_TESTNET,
+  DEFAULT_VALIDITY_DURATION,
+  DUST_LIMIT,
+  ExactBtcScheme,
+  LIGHTNING_MAINNET,
+  LIGHTNING_NETWORKS,
+  LIGHTNING_TESTNET,
+  LightningScheme,
+  MAINNET_ADDRESS_PREFIXES,
+  MIN_RELAY_FEE,
+  SATS_PER_BTC,
+  SCHEME_EXACT,
+  TESTNET_ADDRESS_PREFIXES,
+  btcToSatoshis,
+  isMainnetAddress,
+  isTestnetAddress,
+  isValidHex,
+  registerExactBtcClientScheme,
+  registerExactBtcFacilitatorScheme,
+  registerExactBtcServerScheme,
+  registerLightningClientScheme,
+  registerLightningFacilitatorScheme,
+  registerLightningServerScheme,
+  satoshisToBtc,
+  validateBitcoinAddress,
+  validateBolt11Invoice
+});
+//# sourceMappingURL=index.js.map