@bosonprotocol/x402-server 0.2.0 → 0.3.0-alpha-0

package/dist/cjs/index-COmLTH-U.d.ts

@@ -0,0 +1,292 @@
+import { EscrowPaymentRequirements, Address } from '@bosonprotocol/x402-core/schemes/escrow';
+import { EscrowNextActions, ExchangeState, DisputeState, ChannelRegistry } from '@bosonprotocol/x402-actions';
+import { ExchangeReader } from './onchain/index.js';
+import { a as FacilitatorClient, L as Logger } from './client-B2yejopi.js';
+import { X as X402bServerConfig, e as Store, F as FulfillmentRecoveryEntry, C as CoreSdkReadAdapter } from './config-hnCiZiXF.js';
+import { ExchangeActionId } from '@bosonprotocol/x402-core/state-machine';
+import { Hex } from 'viem';
+
+/** JSON-safe view of a `FulfillmentResult` for the response body. */
+type SerializedFulfillmentResult = {
+    kind: "inline";
+    body: string;
+    contentType: string;
+} | {
+    kind: "async";
+    pointer?: string;
+};
+
+type HandlerStatus = 200 | 400 | 402 | 404 | 409 | 500 | 502;
+type HandlerResult<TBody> = {
+    ok: true;
+    status: 200;
+    body: TBody & {
+        nextActions: EscrowNextActions;
+    };
+} | {
+    ok: false;
+    status: Exclude<HandlerStatus, 200>;
+    body: HandlerErrorBody;
+};
+/**
+ * Result shape for handlers whose success body does NOT carry a
+ * `nextActions` envelope — used by entity-keyed actions
+ * (`boson-withdrawFunds`) and the read-only `available-funds`
+ * endpoint, neither of which advance the exchange state machine.
+ */
+type PlainHandlerResult<TBody> = {
+    ok: true;
+    status: 200;
+    body: TBody;
+} | {
+    ok: false;
+    status: Exclude<HandlerStatus, 200>;
+    body: HandlerErrorBody;
+};
+interface HandlerErrorBody {
+    /** Stable identifier — caller branches on this rather than the human-readable `reason`. */
+    code: string;
+    reason: string;
+    /** Optional rich detail — validator field/expected/got, facilitator code, etc. */
+    details?: unknown;
+}
+interface HandlerWarning {
+    /** Stable identifier — caller branches on this rather than the human-readable `reason`. */
+    code: string;
+    reason: string;
+    /** Optional rich detail — tx hash, exchange id, deferred operation, etc. */
+    details?: unknown;
+}
+declare function handlerOk<TBody>(body: TBody & {
+    nextActions: EscrowNextActions;
+}): HandlerResult<TBody>;
+declare function plainHandlerOk<TBody>(body: TBody): PlainHandlerResult<TBody>;
+declare function handlerErr(status: Exclude<HandlerStatus, 200>, code: string, reason: string, details?: unknown): HandlerResult<never> & PlainHandlerResult<never>;
+
+interface CommitHandlerInput {
+    /** Raw `X-PAYMENT` header value (base64'd JSON). */
+    paymentHeader: string | undefined | null;
+    /** The 402 `PaymentRequirements` the buyer is responding to. */
+    requirements: EscrowPaymentRequirements;
+}
+interface CommitHandlerContext {
+    config: X402bServerConfig;
+    facilitator: FacilitatorClient;
+    exchangeReader: ExchangeReader;
+    fulfillmentRecoveryStore: Store<FulfillmentRecoveryEntry>;
+    /**
+     * Per-exchange fulfillment option policy. Flow A writes the ids
+     * advertised by the original requirements so the redeem-time choice
+     * is constrained to the offer's own channel set.
+     */
+    exchangeFulfillmentOptionStore: Store<readonly string[]>;
+    /** Optional structured logger. Defaults to no-op when absent. */
+    logger?: Logger;
+}
+interface CommitOk {
+    exchangeId: string;
+    txHash: string;
+    /**
+     * Non-fatal post-settle conditions. Today only Flow B uses this slot —
+     * the on-chain redeem may have succeeded while the configured channel
+     * adapter's `onCommit(...)` failed (the buyer's funds and voucher are
+     * already gone; the seller's host needs to recover the delivery target
+     * out-of-band). The exchange state is the wire-format source of truth;
+     * warnings are advisory.
+     */
+    warnings?: HandlerWarning[];
+    /**
+     * Delivery outcome from the fulfillment channel's `onFulfill`, when one
+     * ran. Only Flow B reaches REDEEMED in this handler, so only Flow B can
+     * populate it; `async` carries the out-of-band `pointer`, `inline` a
+     * base64 `body`. Absent when no channel delivered.
+     */
+    fulfillment?: SerializedFulfillmentResult;
+}
+/**
+ * Flow A — `boson-createOfferAndCommit`. Settles via facilitator,
+ * expects the resulting exchange in `COMMITTED`, returns 200 with
+ * `nextActions` advertising the legal post-COMMITTED transitions.
+ */
+declare function handleCommit(input: CommitHandlerInput, ctx: CommitHandlerContext): Promise<HandlerResult<CommitOk>>;
+/**
+ * Flow B — `boson-createOfferCommitAndRedeem`. Same pipeline as
+ * `handleCommit` but verifies the exchange reached `REDEEMED`.
+ */
+declare function handleCommitAndRedeem(input: CommitHandlerInput, ctx: CommitHandlerContext): Promise<HandlerResult<CommitOk>>;
+
+/** Per-action inputs accepted by every post-commit convenience handler. */
+interface PerformActionInput {
+    exchangeId: string;
+    /** ABI-encoded `BosonMetaTx` tuple — see `encodeSignedPayload` in `@bosonprotocol/x402-facilitator`. */
+    signedPayload: Hex;
+}
+/**
+ * Redeem-time variant of `PerformActionInput`. Carries the buyer's
+ * `fulfillment` selection for Flow A — `data` is the delivery target
+ * the redeem-time channel adapter persists. Required when the
+ * original 402 advertised `fulfillment.required = true`; omitted
+ * otherwise.
+ */
+interface RedeemHandlerInput extends PerformActionInput {
+    fulfillment?: {
+        option: string;
+        data: Record<string, unknown> | null;
+    };
+}
+interface PerformActionContext {
+    config: X402bServerConfig;
+    facilitator: FacilitatorClient;
+    exchangeReader: ExchangeReader;
+    /** Optional structured logger. Defaults to no-op when absent. */
+    logger?: Logger;
+}
+interface RedeemHandlerContext extends PerformActionContext {
+    exchangeFulfillmentOptionStore: Store<readonly string[]>;
+    fulfillmentRecoveryStore: Store<FulfillmentRecoveryEntry>;
+}
+interface PerformActionOk {
+    txHash: string;
+    warnings?: HandlerWarning[];
+    /**
+     * Delivery outcome from the fulfillment channel's `onFulfill`, when one
+     * ran (redeem carried `fulfillment` and the channel implements it).
+     * `async` carries the out-of-band `pointer` (e.g. `ipfs://…`); `inline`
+     * carries a base64 `body`. Absent when no channel delivered.
+     */
+    fulfillment?: SerializedFulfillmentResult;
+}
+/**
+ * Generic exchange-keyed post-commit handler — wired from each of the
+ * per-action wrappers below. Entity-keyed actions (e.g. `withdrawFunds`)
+ * have their own handler in `./withdraw-funds.ts`.
+ */
+declare function handlePerformAction(action: ExchangeActionId, input: PerformActionInput, ctx: PerformActionContext): Promise<HandlerResult<PerformActionOk>>;
+/**
+ * Redeem handler. Validates the buyer's `fulfillment` selection (if
+ * present) against the offer's advertised option set and the host's
+ * channel registry, runs the channel's `validate` up-front, then
+ * forwards to the facilitator. The corresponding
+ * `onCommit(exchangeId, data)` upsert is deferred until *after* the
+ * facilitator + state verification confirm the exchange reached
+ * `REDEEMED`, so a failed redeem leaves the stored delivery target
+ * unchanged. The voucher NFT is transferable; whichever wallet signs
+ * `boson-redeem` supplies the delivery data — it's the redeemer's
+ * choice end-to-end.
+ */
+declare function handleRedeem(input: RedeemHandlerInput, ctx: RedeemHandlerContext): Promise<HandlerResult<PerformActionOk>>;
+/** Per-action sugar — preserves the action id at the type level. */
+declare const handleComplete: (input: PerformActionInput, ctx: PerformActionContext) => Promise<HandlerResult<PerformActionOk>>;
+declare const handleDisputeRaise: (input: PerformActionInput, ctx: PerformActionContext) => Promise<HandlerResult<PerformActionOk>>;
+declare const handleDisputeResolve: (input: PerformActionInput, ctx: PerformActionContext) => Promise<HandlerResult<PerformActionOk>>;
+declare const handleDisputeRetract: (input: PerformActionInput, ctx: PerformActionContext) => Promise<HandlerResult<PerformActionOk>>;
+declare const handleDisputeEscalate: (input: PerformActionInput, ctx: PerformActionContext) => Promise<HandlerResult<PerformActionOk>>;
+
+interface WithdrawFundsBaseInput {
+    /** ABI-encoded `BosonMetaTx` tuple — see `encodeSignedPayload` in `@bosonprotocol/x402-evm/codec`. */
+    signedPayload: Hex;
+}
+type WithdrawFundsInput = WithdrawFundsBaseInput & ({
+    entityId: string;
+} | {
+    address: string;
+    role?: "buyer" | "seller";
+});
+interface WithdrawFundsContext {
+    config: X402bServerConfig;
+    facilitator: FacilitatorClient;
+    coreSdkRead: CoreSdkReadAdapter;
+}
+interface WithdrawFundsOk {
+    txHash: string;
+    entityId: string;
+    role?: "buyer" | "seller";
+}
+declare function handleWithdrawFunds(input: WithdrawFundsInput, ctx: WithdrawFundsContext): Promise<PlainHandlerResult<WithdrawFundsOk>>;
+
+interface AvailableFundsEntry {
+    tokenAddress: Address;
+    tokenSymbol: string;
+    tokenName: string;
+    decimals: number;
+    availableAmount: string;
+}
+interface AvailableFundsBody {
+    entityId: string;
+    /** Present when the caller looked up by `address`; omitted when looked up by `entityId`. */
+    role?: "buyer" | "seller";
+    funds: AvailableFundsEntry[];
+}
+type AvailableFundsQuery = {
+    entityId: string;
+} | {
+    address: string;
+    role?: "buyer" | "seller";
+};
+interface AvailableFundsContext {
+    coreSdkRead: CoreSdkReadAdapter;
+}
+declare function handleGetAvailableFunds(query: AvailableFundsQuery, ctx: AvailableFundsContext): Promise<PlainHandlerResult<AvailableFundsBody>>;
+
+interface ResolveEntityInput {
+    address: string;
+    role?: "buyer" | "seller";
+}
+interface ResolveEntityOk {
+    ok: true;
+    entityId: string;
+    role: "buyer" | "seller";
+}
+type ResolveEntityError = {
+    ok: false;
+    code: "NOT_FOUND";
+    reason: string;
+} | {
+    ok: false;
+    code: "AMBIGUOUS";
+    reason: string;
+    /** Seller ids matching the address (one or many). Absent when no sellers matched. */
+    sellerIds?: string[];
+    /** Buyer ids matching the address (one or many). Absent when no buyers matched. */
+    buyerIds?: string[];
+} | {
+    ok: false;
+    code: "SUBGRAPH_FAILURE";
+    reason: string;
+};
+type ResolveEntityResult = ResolveEntityOk | ResolveEntityError;
+declare function resolveEntityId(coreSdk: CoreSdkReadAdapter, input: ResolveEntityInput): Promise<ResolveEntityResult>;
+
+/** Boson account `entityId` — uint256 in decimal-string form, no leading zeros. */
+declare const DECIMAL_UINT_RE: RegExp;
+/** 20-byte EVM address, 0x-prefixed, any letter case (we normalise downstream). */
+declare const ADDRESS_RE: RegExp;
+/**
+ * Hex-string check for `signedPayload`. Requires `0x` followed by an
+ * *even* number of hex digits so the body decodes to whole bytes —
+ * odd-length payloads like `0xabc` would surface as
+ * `signedPayload decode failed: …` deep in the facilitator pipeline,
+ * which is a less precise 502 than the adapter-level 400 this regex
+ * catches. Stricter than core's `HEX_BYTES` (which permits odd
+ * lengths) so we keep this one local.
+ */
+declare const HEX_BYTES_RE: RegExp;
+
+type EmitNextActionsInput = {
+    exchangeId: string;
+} & ({
+    exchangeState: Exclude<ExchangeState, typeof ExchangeState.DISPUTED>;
+    disputeState?: never;
+} | {
+    exchangeState: typeof ExchangeState.DISPUTED;
+    disputeState: DisputeState;
+});
+/**
+ * Build the `nextActions` envelope a handler attaches to its 200 body.
+ * Pure wrapper; the logic beyond `deriveNextActions` is the
+ * `DISPUTED → disputeState required` narrowing and the optional
+ * facilitator-endpoint stamp.
+ */
+declare function emitNextActions(input: EmitNextActionsInput, registry: ChannelRegistry, facilitatorUrl?: string): EscrowNextActions;
+
+export { type AvailableFundsQuery as A, handleDisputeResolve as B, type CommitHandlerInput as C, DECIMAL_UINT_RE as D, type EmitNextActionsInput as E, handleDisputeRetract as F, handleGetAvailableFunds as G, type HandlerResult as H, handlePerformAction as I, handleRedeem as J, handleWithdrawFunds as K, handlerErr as L, handlerOk as M, plainHandlerOk as N, resolveEntityId as O, type PerformActionOk as P, type RedeemHandlerInput as R, type SerializedFulfillmentResult as S, type WithdrawFundsInput as W, type CommitOk as a, type PerformActionInput as b, type PlainHandlerResult as c, type WithdrawFundsOk as d, type AvailableFundsBody as e, ADDRESS_RE as f, type AvailableFundsContext as g, type AvailableFundsEntry as h, type CommitHandlerContext as i, HEX_BYTES_RE as j, type HandlerErrorBody as k, type HandlerStatus as l, type HandlerWarning as m, type PerformActionContext as n, type RedeemHandlerContext as o, type ResolveEntityError as p, type ResolveEntityInput as q, type ResolveEntityOk as r, type ResolveEntityResult as s, type WithdrawFundsContext as t, emitNextActions as u, handleCommit as v, handleCommitAndRedeem as w, handleComplete as x, handleDisputeEscalate as y, handleDisputeRaise as z };

package/dist/cjs/index.d.ts

@@ -1,12 +1,12 @@
 import * as _bosonprotocol_x402_core_schemes_escrow from '@bosonprotocol/x402-core/schemes/escrow';
 import { BosonOfferRef, EscrowPaymentRequirements } from '@bosonprotocol/x402-core/schemes/escrow';
 import { UnsignedFullOffer } from '@bosonprotocol/x402-core/eip712';
-import { X as X402bServerConfig } from './config-CBr9qMps.js';
-export { C as CoreSdkBuyerEntity, a as CoreSdkFundsEntity, b as CoreSdkReadAdapter, c as CoreSdkSellerEntity, F as FulfillmentRecoveryEntry, R as RedeemFulfillmentChannel, S as SellerSigner, d as asCoreSdkReadAdapter, e as assertChannelRegistryEscrowMatch, x as x402bServerConfigSchema } from './config-CBr9qMps.js';
-import { F as FacilitatorClient } from './client-tnrpqVMW.js';
-export { C as CreateFacilitatorClientOptions, a as FetchLike, c as createFacilitatorClient } from './client-tnrpqVMW.js';
-import { CommitHandlerInput, HandlerResult, CommitOk, RedeemHandlerInput, PerformActionOk, PerformActionInput, WithdrawFundsInput, PlainHandlerResult, WithdrawFundsOk, AvailableFundsQuery, AvailableFundsBody } from './handlers/index.js';
-export { ADDRESS_RE, AvailableFundsContext, AvailableFundsEntry, CommitHandlerContext, DECIMAL_UINT_RE, EmitNextActionsInput, HEX_BYTES_RE, HandlerErrorBody, HandlerStatus, HandlerWarning, PerformActionContext, RedeemHandlerContext, ResolveEntityError, ResolveEntityInput, ResolveEntityOk, ResolveEntityResult, WithdrawFundsContext, emitNextActions, handleCommit, handleCommitAndRedeem, handleComplete, handleDisputeEscalate, handleDisputeRaise, handleDisputeResolve, handleDisputeRetract, handleGetAvailableFunds, handlePerformAction, handleRedeem, handleWithdrawFunds, handlerErr, handlerOk, plainHandlerOk, resolveEntityId } from './handlers/index.js';
+import { C as CoreSdkReadAdapter, F as FulfillmentRecoveryEntry, X as X402bServerConfig } from './config-hnCiZiXF.js';
+export { a as CoreSdkBuyerEntity, b as CoreSdkFundsEntity, c as CoreSdkSellerEntity, d as FulfillmentResult, R as RedeemFulfillmentChannel, S as SellerSigner, e as Store, f as asCoreSdkReadAdapter, g as assertChannelRegistryEscrowMatch, i as isStore, m as mapAsStore, x as x402bServerConfigSchema } from './config-hnCiZiXF.js';
+import { a as FacilitatorClient } from './client-B2yejopi.js';
+export { C as CreateFacilitatorClientOptions, F as FacilitatorRetryOptions, b as FetchLike, I as IDEMPOTENCY_KEY_HEADER, L as Logger, c as createFacilitatorClient, n as noopLogger } from './client-B2yejopi.js';
+import { C as CommitHandlerInput, H as HandlerResult, a as CommitOk, R as RedeemHandlerInput, P as PerformActionOk, b as PerformActionInput, W as WithdrawFundsInput, c as PlainHandlerResult, d as WithdrawFundsOk, A as AvailableFundsQuery, e as AvailableFundsBody } from './index-COmLTH-U.js';
+export { f as ADDRESS_RE, g as AvailableFundsContext, h as AvailableFundsEntry, i as CommitHandlerContext, D as DECIMAL_UINT_RE, E as EmitNextActionsInput, j as HEX_BYTES_RE, k as HandlerErrorBody, l as HandlerStatus, m as HandlerWarning, n as PerformActionContext, o as RedeemHandlerContext, p as ResolveEntityError, q as ResolveEntityInput, r as ResolveEntityOk, s as ResolveEntityResult, S as SerializedFulfillmentResult, t as WithdrawFundsContext, u as emitNextActions, v as handleCommit, w as handleCommitAndRedeem, x as handleComplete, y as handleDisputeEscalate, z as handleDisputeRaise, B as handleDisputeResolve, F as handleDisputeRetract, G as handleGetAvailableFunds, I as handlePerformAction, J as handleRedeem, K as handleWithdrawFunds, L as handlerErr, M as handlerOk, N as plainHandlerOk, O as resolveEntityId } from './index-COmLTH-U.js';
 export { BuildPaymentRequirementsArgs, SignFullOfferArgs, buildPaymentRequirements, signFullOffer } from './challenge/index.js';
 export { DecodeErrorCode, DecodeXPaymentResult, ValidatePaymentPayloadArgs, ValidatePaymentPayloadResult, ValidationErrorCode, ValidationWarning, decodeXPaymentHeader, validatePaymentPayload } from './validate/index.js';
 export { FacilitatorHttpError, FacilitatorHttpErrorCode } from './facilitator/index.js';
@@ -18,6 +18,28 @@ import 'zod';
 import '@bosonprotocol/core-sdk';
 import '@bosonprotocol/x402-core/state-machine';
 
+/**
+ * Per-dependency health status.
+ *
+ * - `"ok"` — last probe succeeded
+ * - `"down"` — last probe threw or returned a non-2xx
+ * - `"n/a"` — dependency isn't configured (subgraph is optional —
+ *   commit/redeem-only servers don't have one). For the subgraph
+ *   probe, `"n/a"` means **neither** `coreSdkRead` nor `subgraphUrl`
+ *   was supplied; a configured `subgraphUrl` is materialised on the
+ *   first probe so it always reports `"ok"` / `"down"`.
+ */
+type HealthState = "ok" | "down" | "n/a";
+interface HealthCheckResult {
+    facilitator: HealthState;
+    subgraph: HealthState;
+}
+/** Build a `healthCheck()` function bound to a facilitator client + optional read client. */
+declare function createHealthCheck(deps: {
+    facilitator: FacilitatorClient;
+    coreSdkRead?: CoreSdkReadAdapter | (() => CoreSdkReadAdapter | undefined);
+}): () => Promise<HealthCheckResult>;
+
 /** Per-offer inputs for `server.buildPaymentRequirements` — everything the offer-level args carry, minus the per-server context the factory already holds. */
 interface BuildRequirementsInput {
     /** Already-signed offer reference, or `{ unsigned }` to have the server sign it. */
@@ -31,6 +53,41 @@ interface BuildRequirementsInput {
     maxTimeoutSeconds: number;
     fulfillment?: _bosonprotocol_x402_core_schemes_escrow.FulfillmentRequirements;
 }
+/**
+ * Result of a single `recovery.replay(exchangeId)` call. `{ ok: true }`
+ * means the channel adapter's `onCommit(...)` succeeded and the recovery
+ * entry has been deleted; `{ ok: false, reason }` leaves the entry in
+ * place and reports the failure cause.
+ */
+type RecoveryReplayResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Operator surface for inspecting and replaying the deferred-fulfillment
+ * recovery store. The handlers record an entry when a post-settle
+ * `channel.onCommit(...)` fails or is missing an adapter; the entries
+ * sit until the host replays them out-of-band. This API exposes the
+ * inspection + replay primitives so a host doesn't need to hold the
+ * raw Map reference itself.
+ */
+interface RecoveryApi {
+    /** Snapshot of all pending recovery entries. */
+    list(): Promise<readonly FulfillmentRecoveryEntry[]>;
+    /**
+     * Re-run the channel step that was pending when the entry was
+     * recorded. Branches on `entry.phase`:
+     *   - `"commit"`   → re-runs `channel.onCommit(exchangeId, entry.data)`.
+     *   - `"delivery"` → re-runs `channel.onFulfill(exchangeId)` (the
+     *     prior `onCommit` already persisted).
+     * Deletes the entry on success; leaves it (with an updated `error`
+     * field) on failure. A `"delivery"` entry whose channel has no
+     * `onFulfill` returns `{ ok: false }` with the entry retained.
+     */
+    replay(exchangeId: string): Promise<RecoveryReplayResult>;
+}
 interface X402bServer {
     readonly config: X402bServerConfig;
     readonly facilitator: FacilitatorClient;
@@ -51,6 +108,19 @@ interface X402bServer {
         withdrawFunds(input: WithdrawFundsInput): Promise<PlainHandlerResult<WithdrawFundsOk>>;
         getAvailableFunds(query: AvailableFundsQuery): Promise<PlainHandlerResult<AvailableFundsBody>>;
     };
+    /**
+     * Operator API for the deferred-fulfillment recovery queue. See
+     * `RecoveryApi` and `docs/boson-impl-05-server-sdk.md` for the
+     * operator runbook.
+     */
+    readonly recovery: RecoveryApi;
+    /**
+     * Liveness probe — pings the facilitator's `/healthz` and (if a
+     * subgraph / read client is configured) a cheap subgraph read. Hosts
+     * mount this behind whatever `/healthz` / `/readyz` route their
+     * framework uses.
+     */
+    healthCheck(): Promise<HealthCheckResult>;
 }
 /**
  * Validate a config and return a `X402bServer` whose methods are
@@ -69,4 +139,18 @@ declare function encodeXPaymentResponse(body: unknown): string;
 /** Canonical header name — exported so adapters share one spelling. */
 declare const X_PAYMENT_RESPONSE_HEADER: "X-PAYMENT-RESPONSE";
 
-export { AvailableFundsBody, AvailableFundsQuery, type BuildRequirementsInput, CommitHandlerInput, CommitOk, FacilitatorClient, HandlerResult, PerformActionInput, PerformActionOk, PlainHandlerResult, RedeemHandlerInput, WithdrawFundsInput, WithdrawFundsOk, type X402bServer, X402bServerConfig, X_PAYMENT_RESPONSE_HEADER, createX402bServer, encodeXPaymentResponse };
+interface KeyedMutex<K> {
+    /**
+     * Run `fn` once any previously-queued work for `key` has settled.
+     * Successive callers for the same `key` queue in FIFO order; callers
+     * for different keys run independently.
+     *
+     * `fn`'s resolution and rejection are surfaced to the caller
+     * directly — the mutex itself never alters the return value or
+     * masks errors.
+     */
+    runExclusive<T>(key: K, fn: () => Promise<T>): Promise<T>;
+}
+declare function createKeyedMutex<K>(): KeyedMutex<K>;
+
+export { AvailableFundsBody, AvailableFundsQuery, type BuildRequirementsInput, CommitHandlerInput, CommitOk, CoreSdkReadAdapter, FacilitatorClient, FulfillmentRecoveryEntry, HandlerResult, type HealthCheckResult, type HealthState, type KeyedMutex, PerformActionInput, PerformActionOk, PlainHandlerResult, type RecoveryApi, type RecoveryReplayResult, RedeemHandlerInput, WithdrawFundsInput, WithdrawFundsOk, type X402bServer, X402bServerConfig, X_PAYMENT_RESPONSE_HEADER, createHealthCheck, createKeyedMutex, createX402bServer, encodeXPaymentResponse };