xytara 3.1.16 → 3.2.0

package/lib/payment_rail_truth_contract.js

@@ -1,324 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const { summarizePaymentProtocolPack, buildPaymentProtocolStrategyPack } = require("./payment_protocol_contract");
-const { summarizePaymentFrontRegistryPack } = require("./payment_front_registry");
-const { summarizeX402LanePack } = require("./x402_lane_contract");
-const { summarizeStripeMppLanePack } = require("./stripe_mpp_lane_contract");
-const { summarizeL402LanePack } = require("./l402_lane_contract");
-const { summarizeBoltLanePack } = require("./bolt_lane_contract");
-const { summarizeSettlementLanePack } = require("./settlement_lane_contract");
-const { summarizeStablecoinLanePack } = require("./stablecoin_lane_contract");
-const { summarizeMajorRailsLanePack } = require("./major_rails_lane_contract");
-const { buildTreasuryDestinationsPack, summarizeTreasuryDestinationsPack } = require("./treasury_destinations_contract");
-const { summarizeTreasuryLanePack } = require("./treasury_lane_contract");
-
-function uniqueSorted(values) {
-  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
-}
-
-function buildFrontProfile(entry) {
-  return {
-    profile_id: entry.profile_id,
-    profile_kind: "payment_front",
-    profile_label: entry.profile_label,
-    actor_fit: uniqueSorted(entry.actor_fit),
-    payment_method_fit: uniqueSorted(entry.payment_method_fit),
-    runtime_execution_ready: Boolean(entry.runtime_execution_ready),
-    proof_followthrough_ready: Boolean(entry.proof_followthrough_ready),
-    launch_default: Boolean(entry.launch_default),
-    claim_status: entry.claim_status,
-    treasury_live_claim_dependency: entry.treasury_live_claim_dependency,
-    summary: entry.summary,
-    linked_surfaces: entry.linked_surfaces,
-    claim_boundary: entry.claim_boundary
-  };
-}
-
-function buildRailProfile(entry) {
-  return {
-    profile_id: entry.profile_id,
-    profile_kind: "settlement_or_treasury_rail",
-    profile_label: entry.profile_label,
-    asset_family: uniqueSorted(entry.asset_family),
-    settlement_family: entry.settlement_family,
-    runtime_path_ready: Boolean(entry.runtime_path_ready),
-    public_live_landing_claim_allowed: Boolean(entry.public_live_landing_claim_allowed),
-    public_claim_status: entry.public_claim_status,
-    launch_role: entry.launch_role,
-    treasury_profile: entry.treasury_profile,
-    linked_surfaces: entry.linked_surfaces,
-    claim_boundary: entry.claim_boundary
-  };
-}
-
-function buildPaymentRailTruthPack() {
-  const paymentProtocolSummary = summarizePaymentProtocolPack();
-  const paymentStrategy = buildPaymentProtocolStrategyPack();
-  const paymentFrontRegistrySummary = summarizePaymentFrontRegistryPack();
-  const x402Summary = summarizeX402LanePack();
-  const stripeMppSummary = summarizeStripeMppLanePack();
-  const l402Summary = summarizeL402LanePack();
-  const boltSummary = summarizeBoltLanePack();
-  const settlementSummary = summarizeSettlementLanePack();
-  const stablecoinSummary = summarizeStablecoinLanePack();
-  const majorRailsSummary = summarizeMajorRailsLanePack();
-  const treasuryLaneSummary = summarizeTreasuryLanePack();
-  const treasuryPack = buildTreasuryDestinationsPack();
-  const treasurySummary = summarizeTreasuryDestinationsPack();
-  const treasuryProfileByRail = new Map((treasuryPack.profiles || []).map((profile) => [profile.rail_id, profile]));
-
-  const frontProfiles = [
-    buildFrontProfile({
-      profile_id: "x402_direct_machine_payment",
-      profile_label: "x402 direct machine payment",
-      actor_fit: ["machine", "agent", "developer", "enterprise"],
-      payment_method_fit: ["direct_machine_payment", "signed_request_payment"],
-      runtime_execution_ready: true,
-      proof_followthrough_ready: true,
-      launch_default: true,
-      claim_status: "bounded_live_first_party_default",
-      treasury_live_claim_dependency: "requires_real_configured_treasury_destination_to_claim_specific_live_landing_rail",
-      summary: x402Summary,
-      linked_surfaces: x402Summary.linked_surfaces,
-      claim_boundary: "claim_the_x402_quote_challenge_pay_execute_lane_as_first_party_default_without_claiming_any_specific_external_custody_or_treasury_rail_until_configured"
-    }),
-    buildFrontProfile({
-      profile_id: "account_credits_repeat_use",
-      profile_label: "account credits repeat-use spend",
-      actor_fit: ["agent", "machine", "operator", "enterprise", "human"],
-      payment_method_fit: ["internal_credits", "reusable_balance", "delegated_spend"],
-      runtime_execution_ready: true,
-      proof_followthrough_ready: true,
-      launch_default: true,
-      claim_status: "bounded_live_first_party_repeat_use",
-      treasury_live_claim_dependency: "money_in_may_arrive_from_hosted_checkout_or_external_grant_but_runtime_spend_path_is_first_party",
-      summary: {
-        product: packageJson.name,
-        category: "machine-commerce-account-credits-front",
-        summary_version: "xytara-account-credits-front-summary-v2",
-        posture: "funded_repeat_use_execution"
-      },
-      linked_surfaces: {
-        credit_packs_ref: "/v1/credit-packs/summary",
-        credit_balance_ref_template: "/v1/economics/accounts/:account_id/credit-balance",
-        execute_ref: "/v1/commands/execute",
-        entitlements_ref_template: "/v1/economics/accounts/:account_id/entitlements"
-      },
-      claim_boundary: "claim_the_credits_first_runtime_spend_path_without_claiming_hidden_money_in_or_universal_external_funding_posture"
-    }),
-    buildFrontProfile({
-      profile_id: "hosted_checkout_money_in",
-      profile_label: "hosted checkout and external funding",
-      actor_fit: ["human", "enterprise", "operator"],
-      payment_method_fit: ["hosted_checkout", "fiat_money_in", "browser_payment"],
-      runtime_execution_ready: true,
-      proof_followthrough_ready: true,
-      launch_default: true,
-      claim_status: "bounded_live_first_party_human_checkout",
-      treasury_live_claim_dependency: "requires_real_configured_rail_destinations_to_publicly_claim_specific_live_landing_paths",
-      summary: stripeMppSummary,
-      linked_surfaces: stripeMppSummary.linked_surfaces,
-      claim_boundary: "claim_the_hosted_checkout_money_in_and_runtime_dispatch_lane_without_making_provider_specific_checkout_semantics_the_center_of_the_stack"
-    }),
-    buildFrontProfile({
-      profile_id: "l402_permissionless_front",
-      profile_label: "L402 permissionless payment front",
-      actor_fit: ["agent", "machine", "operator"],
-      payment_method_fit: ["lightning", "permissionless_micro_payment"],
-      runtime_execution_ready: true,
-      proof_followthrough_ready: true,
-      launch_default: false,
-      claim_status: "adapter_front_ready_not_launch_default",
-      treasury_live_claim_dependency: "front_only_until_operator_binds_real_verifier_and_treasury_runtime",
-      summary: l402Summary,
-      linked_surfaces: l402Summary.linked_surfaces,
-      claim_boundary: "claim_l402_as_an_optional_adapter_front_into_the_same_runtime_core_not_as_a_first_party_launch_default_or_built_in_lightning_settlement_runtime"
-    }),
-    buildFrontProfile({
-      profile_id: "bolt_utxo_spv_front",
-      profile_label: "BOLT / UTXO-SPV payment front",
-      actor_fit: ["agent", "machine", "operator"],
-      payment_method_fit: ["utxo_native_payment", "spv_verifiable_payment"],
-      runtime_execution_ready: true,
-      proof_followthrough_ready: true,
-      launch_default: false,
-      claim_status: "adapter_front_ready_not_launch_default",
-      treasury_live_claim_dependency: "front_only_until_operator_binds_real_runtime_and_treasury_posture",
-      summary: boltSummary,
-      linked_surfaces: boltSummary.linked_surfaces,
-      claim_boundary: "claim_bolt_or_utxo_spv_as_optional_fronts_into_the_same_execution_core_not_as_a_first_party_launch_default_or_unbounded_chain_runtime"
-    })
-  ];
-
-  const railProfiles = [
-    buildRailProfile({
-      profile_id: "bsv_teranode_native",
-      profile_label: "BSV / Teranode native settlement",
-      asset_family: ["bsv", "native_chain_settlement"],
-      settlement_family: "native_bsv_family",
-      runtime_path_ready: true,
-      public_live_landing_claim_allowed: Boolean((treasuryProfileByRail.get("bsv_teranode") || {}).public_claim_allowed),
-      public_claim_status: (treasuryProfileByRail.get("bsv_teranode") || {}).public_claim_status || "readiness_template_only",
-      launch_role: "primary_native_settlement_family",
-      treasury_profile: treasuryProfileByRail.get("bsv_teranode") || null,
-      linked_surfaces: {
-        settlement_ref: "/v1/settlement",
-        native_settlement_ref: "/v1/settlement/bsv-teranode",
-        native_readiness_ref: "/v1/settlement/bsv-teranode/readiness",
-        treasury_destinations_ref: "/v1/treasury-destinations"
-      },
-      claim_boundary: "claim_the_native_bsv_runtime_and_readiness_posture_now_but_only_claim_live_public_treasury_landing_when_the_bsv_destination_is_really_configured"
-    }),
-    buildRailProfile({
-      profile_id: "stablecoin_family",
-      profile_label: "stablecoin settlement family",
-      asset_family: ["usdc", "stable_value"],
-      settlement_family: "evm_and_stable_family",
-      runtime_path_ready: true,
-      public_live_landing_claim_allowed: ["usdc", "dai", "base", "evm"].some((railId) => {
-        const profile = treasuryProfileByRail.get(railId);
-        return profile && profile.public_claim_allowed === true;
-      }),
-      public_claim_status: ["usdc", "dai", "base", "evm"].some((railId) => {
-        const profile = treasuryProfileByRail.get(railId);
-        return profile && profile.public_claim_allowed === true;
-      }) ? "partially_live_claimable_when_configured" : "readiness_template_only",
-      launch_role: "supported_first_party_stable_value_runtime_family",
-      treasury_profile: {
-        live_claimable_rails: ["usdc", "dai", "base", "evm"].filter((railId) => {
-          const profile = treasuryProfileByRail.get(railId);
-          return profile && profile.public_claim_allowed === true;
-        }),
-        readiness_only_rails: ["usdc", "dai", "base", "evm"].filter((railId) => {
-          const profile = treasuryProfileByRail.get(railId);
-          return !profile || profile.public_claim_allowed !== true;
-        })
-      },
-      linked_surfaces: {
-        stablecoins_ref: "/v1/stablecoins",
-        settlement_ref: "/v1/settlement",
-        treasury_destinations_ref: "/v1/treasury-destinations"
-      },
-      claim_boundary: "claim_the_stablecoin_runtime_family_and_lane_summaries_now_but_only_claim_specific_live_public_landing_rails_when_the_corresponding_destinations_are_explicitly_configured"
-    }),
-    buildRailProfile({
-      profile_id: "major_rails_family",
-      profile_label: "major alternative rails family",
-      asset_family: ["solana", "antelope", "xpr", "metal", "hedera_hbar", "kaspa_kas", "polkadot_dot", "digibyte_dgb", "constellation_dag"],
-      settlement_family: "major_alternative_rails_family",
-      runtime_path_ready: true,
-      public_live_landing_claim_allowed: ["solana_payment", "antelope_payment", "xpr_payment", "metal_payment", "hedera_hbar", "kaspa_kas", "polkadot_dot", "digibyte_dgb", "constellation_dag"].some((railId) => {
-        const profile = treasuryProfileByRail.get(railId);
-        return profile && profile.public_claim_allowed === true;
-      }),
-      public_claim_status: ["solana_payment", "antelope_payment", "xpr_payment", "metal_payment", "hedera_hbar", "kaspa_kas", "polkadot_dot", "digibyte_dgb", "constellation_dag"].some((railId) => {
-        const profile = treasuryProfileByRail.get(railId);
-        return profile && profile.public_claim_allowed === true;
-      }) ? "partially_live_claimable_when_configured" : "readiness_template_only",
-      launch_role: "supported_non_default_settlement_breadth_family",
-      treasury_profile: {
-        live_claimable_rails: ["solana_payment", "antelope_payment", "xpr_payment", "metal_payment", "hedera_hbar", "kaspa_kas", "polkadot_dot", "digibyte_dgb", "constellation_dag"].filter((railId) => {
-          const profile = treasuryProfileByRail.get(railId);
-          return profile && profile.public_claim_allowed === true;
-        }),
-        readiness_only_rails: ["solana_payment", "antelope_payment", "xpr_payment", "metal_payment", "hedera_hbar", "kaspa_kas", "polkadot_dot", "digibyte_dgb", "constellation_dag"].filter((railId) => {
-          const profile = treasuryProfileByRail.get(railId);
-          return !profile || profile.public_claim_allowed !== true;
-        })
-      },
-      linked_surfaces: {
-        major_rails_ref: "/v1/major-rails",
-        settlement_ref: "/v1/settlement",
-        treasury_destinations_ref: "/v1/treasury-destinations"
-      },
-      claim_boundary: "claim_major_rails_as_supported_runtime_breadth_now_but_only_claim_specific_live_public_landing_rails_when_real_destinations_exist_for_them"
-    })
-  ];
-
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-payment-rail-truth-model",
-    pack_version: "xytara-payment-rail-truth-model-v1",
-    posture: "payment_front_truth_plus_rail_claim_discipline",
-    model_state: "frozen_for_3_0_0_closeout",
-    doctrine: "payment_fronts_can_be_live_and_callable_before_every_treasury_rail_is_publicly_claimable_but_the_stack_must_never_blur_that_boundary",
-    core_claim: "xytara supports real payment admission and execution from multiple surfaces while making live treasury landing claims only for explicitly configured rails",
-    defaults: {
-      primary_machine_payment_front: paymentStrategy.operator_decisions.launch_primary_machine_lane,
-      primary_human_payment_front: paymentStrategy.operator_decisions.launch_primary_human_lane,
-      primary_repeat_use_payment_front: paymentStrategy.operator_decisions.launch_repeat_use_lane,
-      default_settlement_mode: settlementSummary.default_settlement_mode,
-      launch_default_payment_protocol: paymentProtocolSummary.default_protocol
-    },
-    front_profile_count: frontProfiles.length,
-    rail_profile_count: railProfiles.length,
-    launch_default_front_count: frontProfiles.filter((entry) => entry.launch_default).length,
-    callable_front_count: frontProfiles.filter((entry) => entry.runtime_execution_ready).length,
-    public_live_landing_rail_count: (treasurySummary.public_claim_boundary && treasurySummary.public_claim_boundary.live_claimable_rails || []).length,
-    front_profiles: frontProfiles,
-    rail_profiles: railProfiles,
-    operator_rules: [
-      "treat_payment_fronts_and_treasury_rails_as_related_but_not_identical_claim_surfaces",
-      "only_rails_with_public_claim_allowed_true_may_be_described_as_live_public_landing_paths",
-      "keep_operator_only_custody_and_destination_refs_out_of_public_surfaces",
-      "do_not_split_runtime_or_proof_semantics_by_payment_method"
-    ],
-    linked_summaries: {
-      payment_protocol_summary: paymentProtocolSummary,
-      payment_front_registry_summary: paymentFrontRegistrySummary,
-      settlement_lane_summary: settlementSummary,
-      stablecoin_lane_summary: stablecoinSummary,
-      major_rails_lane_summary: majorRailsSummary,
-      treasury_lane_summary: treasuryLaneSummary,
-      treasury_destinations_summary: treasurySummary
-    },
-    linked_surfaces: {
-      payment_protocols_ref: "/v1/payment-protocols",
-      payment_fronts_ref: "/v1/payment-fronts",
-      x402_ref: "/v1/x402",
-      stripe_mpp_ref: "/v1/stripe-mpp",
-      l402_ref: "/v1/l402",
-      bolt_ref: "/v1/bolt",
-      settlement_ref: "/v1/settlement",
-      stablecoins_ref: "/v1/stablecoins",
-      major_rails_ref: "/v1/major-rails",
-      treasury_ref: "/v1/treasury",
-      treasury_destinations_ref: "/v1/treasury-destinations",
-      payment_setup_doc_ref: "REAL_PAYMENT_SETUP.md"
-    },
-    public_claim_boundary: treasurySummary.public_claim_boundary,
-    claim_boundary: "claim_callable_payment_admission_and_runtime_execution_lanes_now_while_reserving_live_public_treasury_landing_claims_only_for_explicitly_configured_rails"
-  };
-}
-
-function summarizePaymentRailTruthPack() {
-  const pack = buildPaymentRailTruthPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    summary_version: "xytara-payment-rail-truth-model-summary-v1",
-    pack_version: pack.pack_version,
-    model_state: pack.model_state,
-    front_profile_count: pack.front_profile_count,
-    rail_profile_count: pack.rail_profile_count,
-    launch_default_front_count: pack.launch_default_front_count,
-    callable_front_count: pack.callable_front_count,
-    public_live_landing_rail_count: pack.public_live_landing_rail_count,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-function getPaymentRailTruthProfileDetail(profileId) {
-  const normalized = String(profileId || "").trim().toLowerCase();
-  const pack = buildPaymentRailTruthPack();
-  return [...(pack.front_profiles || []), ...(pack.rail_profiles || [])].find((entry) => entry.profile_id === normalized) || null;
-}
-
-module.exports = {
-  buildPaymentRailTruthPack,
-  summarizePaymentRailTruthPack,
-  getPaymentRailTruthProfileDetail
-};

package/lib/payment_verification.js

@@ -1,357 +0,0 @@
-"use strict";
-
-const crypto = require("crypto");
-const { loadPaymentConfig } = require("./payment_config");
-const {
-  createFacilitatorClient,
-  verifyX402Payment,
-  settleX402Payment,
-  encodePaymentResponse
-} = require("./x402_facilitator");
-const { parseL402Authorization, verifyL402AccessToken } = require("./l402_payment_front");
-const { parseBoltAuthorization, verifyBoltAccessToken } = require("./bolt_payment_front");
-const { parseStripeMppAuthorization, verifyStripeMppAccessToken } = require("./stripe_mpp_payment_front");
-const {
-  buildBsvTeranodeSettlementHints,
-  extractBsvTeranodePaymentReference,
-  isBsvTeranodeSettlementMode,
-  normalizeSettlementMode
-} = require("./settlement_bsv_teranode");
-
-function decodeBase64UrlJson(value) {
-  try {
-    return JSON.parse(Buffer.from(String(value || ""), "base64url").toString("utf8"));
-  } catch (_) {
-    return null;
-  }
-}
-
-function safeEqualHex(left, right) {
-  const a = Buffer.from(String(left || ""), "hex");
-  const b = Buffer.from(String(right || ""), "hex");
-  if (a.length === 0 || b.length === 0 || a.length !== b.length) return false;
-  return crypto.timingSafeEqual(a, b);
-}
-
-function parseNativePaymentHeaders(headers) {
-  return {
-    wallet_id: headers["x-wallet-id"] || null,
-    encoded: headers["x-payment"] || null,
-    signature: headers["x-payment-signature"] || null,
-    scheme: "native"
-  };
-}
-
-function parseInstantPaymentHeaders(headers) {
-  const decoded = decodeBase64UrlJson(headers["payment-signature"]);
-  if (!decoded || typeof decoded !== "object") return null;
-  return {
-    wallet_id: decoded.wallet_id || null,
-    encoded: decoded.payload || null,
-    signature: decoded.signature || null,
-    scheme: decoded.scheme || "exact"
-  };
-}
-
-function parsePayment(headers, requiredHeaders, options) {
-  const required = Array.isArray(requiredHeaders) ? requiredHeaders : [];
-  const opts = options || {};
-  if (required.includes("authorization")) {
-    if (opts.authorization_scheme === "mpp" || opts.payment_protocol === "mpp") return parseStripeMppAuthorization(headers);
-    if (opts.authorization_scheme === "bolt" || opts.payment_protocol === "bolt") return parseBoltAuthorization(headers);
-    return parseL402Authorization(headers);
-  }
-  if (required.includes("payment-signature")) return parseInstantPaymentHeaders(headers);
-  return parseNativePaymentHeaders(headers);
-}
-
-function decodePaymentPayload(encoded) {
-  try {
-    return JSON.parse(Buffer.from(String(encoded || ""), "base64url").toString("utf8"));
-  } catch (_) {
-    return null;
-  }
-}
-
-function verifyPaymentPayloadAgainstQuote(paymentPayload, quote, walletId, maxAgeSeconds) {
-  if (!paymentPayload || typeof paymentPayload !== "object") {
-    return { ok: false, reason: "payment_payload_invalid" };
-  }
-  if (!paymentPayload.quote_id || paymentPayload.quote_id !== quote.quote_id) {
-    return { ok: false, reason: "payment_quote_mismatch" };
-  }
-  if (paymentPayload.amount_minor !== quote.amount_minor) {
-    return { ok: false, reason: "payment_amount_mismatch" };
-  }
-  if (paymentPayload.currency !== quote.currency) {
-    return { ok: false, reason: "payment_currency_mismatch" };
-  }
-  if (paymentPayload.account_id && paymentPayload.account_id !== quote.account_id) {
-    return { ok: false, reason: "payment_account_mismatch" };
-  }
-  if (walletId && paymentPayload.wallet_id && paymentPayload.wallet_id !== walletId) {
-    return { ok: false, reason: "payment_wallet_mismatch" };
-  }
-  if (
-    paymentPayload.settlement_mode &&
-    normalizeSettlementMode(paymentPayload.settlement_mode) !== normalizeSettlementMode(quote.settlement_mode)
-  ) {
-    return { ok: false, reason: "payment_settlement_mode_mismatch" };
-  }
-  if (
-    quote.settlement_binding_hash
-    && paymentPayload.settlement_binding_hash
-    && paymentPayload.settlement_binding_hash !== quote.settlement_binding_hash
-  ) {
-    return { ok: false, reason: "payment_settlement_binding_mismatch" };
-  }
-  if (isBsvTeranodeSettlementMode(quote.settlement_mode)) {
-    const settlementHints = buildBsvTeranodeSettlementHints({
-      settlementMode: quote.settlement_mode,
-      amountMinor: quote.amount_minor,
-      currency: quote.currency,
-      settlementBindingHash: quote.settlement_binding_hash,
-      treasuryDestination: quote.treasury
-    });
-    const bsvReference = extractBsvTeranodePaymentReference(paymentPayload);
-    if (bsvReference) {
-      if (bsvReference.network && settlementHints && bsvReference.network !== settlementHints.network) {
-        return { ok: false, reason: "payment_bsv_network_mismatch" };
-      }
-      if (
-        settlementHints &&
-        settlementHints.merchant_address &&
-        bsvReference.merchant_address &&
-        bsvReference.merchant_address !== settlementHints.merchant_address
-      ) {
-        return { ok: false, reason: "payment_bsv_merchant_address_mismatch" };
-      }
-      if (
-        settlementHints &&
-        settlementHints.merchant_paymail &&
-        bsvReference.merchant_paymail &&
-        bsvReference.merchant_paymail !== settlementHints.merchant_paymail
-      ) {
-        return { ok: false, reason: "payment_bsv_merchant_paymail_mismatch" };
-      }
-      if (
-        settlementHints &&
-        Number.isFinite(Number(bsvReference.amount_satoshis)) &&
-        Number(bsvReference.amount_satoshis) !== settlementHints.amount_satoshis
-      ) {
-        return { ok: false, reason: "payment_bsv_amount_mismatch" };
-      }
-      if (
-        settlementHints &&
-        bsvReference.settlement_reference &&
-        bsvReference.settlement_reference !== settlementHints.settlement_reference
-      ) {
-        return { ok: false, reason: "payment_bsv_reference_mismatch" };
-      }
-    }
-  }
-  if (!paymentPayload.nonce || typeof paymentPayload.nonce !== "string") {
-    return { ok: false, reason: "payment_nonce_missing" };
-  }
-  if (!paymentPayload.issued_at_iso || Number.isNaN(Date.parse(paymentPayload.issued_at_iso))) {
-    return { ok: false, reason: "payment_issued_at_invalid" };
-  }
-  const ageSeconds = Math.max(0, Math.floor((Date.now() - Date.parse(paymentPayload.issued_at_iso)) / 1000));
-  if (ageSeconds > maxAgeSeconds) {
-    return { ok: false, reason: "payment_expired" };
-  }
-  return { ok: true, age_seconds: ageSeconds };
-}
-
-async function verifyPaymentAcceptance(state, headers, requiredHeaders, quote, options) {
-  const config = loadPaymentConfig();
-  const required = Array.isArray(requiredHeaders) ? requiredHeaders : [];
-  const opts = options || {};
-  // Trustless on-chain pay-per-call: the PAYMENT-SIGNATURE carries an x402 v2 payment,
-  // which a facilitator verifies and settles on-chain before any work runs. This path is
-  // opt-in (XYTARA_PAYMENT_VERIFICATION_MODE=x402_facilitator) and fails closed if the
-  // facilitator is unreachable or the payment does not settle.
-  if (config.verification_mode === "x402_facilitator" && required.includes("payment-signature")) {
-    const h = headers || {};
-    const facilitator = createFacilitatorClient({
-      url: config.x402.facilitator_url,
-      headers: config.x402.facilitator_headers,
-      timeoutMs: config.x402.facilitator_timeout_ms,
-      cdp: config.x402.cdp
-    });
-    const auth = await verifyX402Payment({
-      paymentHeader: h["payment-signature"],
-      accepts: config.x402.accepts,
-      resourceUrl: opts.resource_url || null,
-      facilitator
-    });
-    if (!auth.ok) {
-      return { ok: false, status: auth.status || 402, reason: auth.reason, detail: auth.detail || null };
-    }
-    const authorizationView = {
-      ok: true,
-      verification_mode: "x402_facilitator",
-      wallet_id: auth.authorization.payer,
-      payment_payload: {
-        x402_payer: auth.authorization.payer,
-        x402_network: auth.authorization.paymentRequirements.network,
-        x402_asset: auth.authorization.paymentRequirements.asset,
-        x402_amount: auth.authorization.paymentRequirements.amount,
-        x402_pay_to: auth.authorization.paymentRequirements.payTo || null
-      }
-    };
-    // Deferred settlement: verify now, settle only AFTER execution succeeds, so a
-    // failed call is never settled/charged. The caller must call settleDeferredPayment
-    // on success. (The EIP-3009 authorization stays valid for maxTimeoutSeconds, so
-    // verify->execute->settle must complete within that window.)
-    if (opts.deferSettlement) {
-      return {
-        ...authorizationView,
-        settlement: null,
-        payment_response_base64: null,
-        deferred_settlement: {
-          protocol: "x402_facilitator",
-          authorization: auth.authorization,
-          facilitator,
-          settle: config.x402.settle
-        }
-      };
-    }
-    const settled = await settleX402Payment({ authorization: auth.authorization, facilitator, settle: config.x402.settle });
-    if (!settled.ok) {
-      return { ok: false, status: settled.status || 402, reason: settled.reason, detail: settled.detail || null };
-    }
-    return {
-      ...authorizationView,
-      settlement: settled.settlement,
-      payment_response_base64: encodePaymentResponse(settled.settlement)
-    };
-  }
-  if (required.includes("authorization")) {
-    if (opts.authorization_scheme === "mpp" || opts.payment_protocol === "mpp") {
-      return verifyStripeMppAccessToken(headers || {}, quote, state);
-    }
-    if (opts.authorization_scheme === "bolt" || opts.payment_protocol === "bolt") {
-      return verifyBoltAccessToken(headers || {}, quote, state);
-    }
-    return verifyL402AccessToken(headers || {}, quote, state);
-  }
-  const payment = parsePayment(headers || {}, requiredHeaders, opts);
-  // x402_facilitator only governs the x402 (payment-signature) routes, handled above.
-  // On the native and instant routes it falls back to local_signed, so enabling the mode
-  // adds trustless on-chain settlement without disabling the existing paid lanes.
-  const nativeMode = config.verification_mode === "x402_facilitator" ? "local_signed" : config.verification_mode;
-  if (nativeMode === "presence") {
-    return {
-      ok: true,
-      verification_mode: "presence",
-      wallet_id: payment && payment.wallet_id ? payment.wallet_id : null,
-      payment_payload: payment && payment.encoded ? decodePaymentPayload(payment.encoded) : null
-    };
-  }
-
-  if (nativeMode !== "local_signed") {
-    return {
-      ok: false,
-      status: 400,
-      reason: "payment_verification_mode_unsupported"
-    };
-  }
-
-  if (!payment || !payment.wallet_id || !payment.encoded || !payment.signature) {
-    return {
-      ok: false,
-      status: 402,
-      reason: "payment_headers_incomplete"
-    };
-  }
-
-  const walletEntry = config.wallet_registry.get(payment.wallet_id);
-  if (!walletEntry || walletEntry.enabled === false) {
-    return {
-      ok: false,
-      status: 403,
-      reason: "wallet_not_registered"
-    };
-  }
-
-  const expectedSignature = crypto.createHmac("sha256", walletEntry.secret).update(payment.encoded).digest("hex");
-  if (!safeEqualHex(expectedSignature, payment.signature)) {
-    return {
-      ok: false,
-      status: 403,
-      reason: "payment_signature_invalid"
-    };
-  }
-
-  const paymentPayload = decodePaymentPayload(payment.encoded);
-  const payloadValidation = verifyPaymentPayloadAgainstQuote(
-    paymentPayload,
-    quote,
-    payment.wallet_id,
-    config.payment_max_age_seconds
-  );
-  if (!payloadValidation.ok) {
-    return {
-      ok: false,
-      status: 403,
-      reason: payloadValidation.reason
-    };
-  }
-
-  if (state && state.acceptedPaymentNonces && state.acceptedPaymentNonces.has(paymentPayload.nonce)) {
-    return {
-      ok: false,
-      status: 409,
-      reason: "payment_nonce_replayed"
-    };
-  }
-
-  return {
-    ok: true,
-    verification_mode: "local_signed",
-    wallet_id: payment.wallet_id,
-    payment_payload: paymentPayload,
-    age_seconds: payloadValidation.age_seconds
-  };
-}
-
-function markPaymentAccepted(state, verification) {
-  if (
-    state
-    && state.acceptedPaymentNonces
-    && verification
-    && verification.payment_payload
-    && verification.payment_payload.nonce
-  ) {
-    state.acceptedPaymentNonces.add(verification.payment_payload.nonce);
-  }
-}
-
-// Settle a payment whose settlement was deferred until after successful execution
-// (see opts.deferSettlement). For verification results WITHOUT a deferred settlement
-// — native/credit schemes, and the external rails (L402/BOLT/MPP) whose funds already
-// moved before the proof was presented — this is a no-op success (nothing for us to
-// settle). Returns { ok, settlement?, payment_response_base64? } | { ok:false, status, reason, detail }.
-async function settleDeferredPayment(verification) {
-  const deferred = verification && verification.deferred_settlement;
-  if (!deferred) return { ok: true };
-  if (deferred.protocol === "x402_facilitator") {
-    const settled = await settleX402Payment({
-      authorization: deferred.authorization,
-      facilitator: deferred.facilitator,
-      settle: deferred.settle
-    });
-    if (!settled.ok) {
-      return { ok: false, status: settled.status || 402, reason: settled.reason, detail: settled.detail || null };
-    }
-    return { ok: true, settlement: settled.settlement, payment_response_base64: encodePaymentResponse(settled.settlement) };
-  }
-  return { ok: true };
-}
-
-module.exports = {
-  markPaymentAccepted,
-  settleDeferredPayment,
-  verifyPaymentAcceptance
-};