@playmos/sdk 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -23,6 +23,333 @@ interface ResolvedEnv {
     isTest: boolean;
 }
 
+/**
+ * settlement.ts — the x402-ready settlement CORE contract (Phase 0).
+ *
+ * Two shared shapes every value-movement primitive (`transfer`, `escrow`,
+ * `marketplace`) AND the future x402 adapter build on. The whole point of
+ * naming them now is that x402 later becomes a thin HTTP-402 adapter with zero
+ * rework — see `docs/design/transfer-escrow-marketplace-spec.md` §"Architecture:
+ * x402-ready by design".
+ *
+ *   PaymentRequirement — WHAT must be paid. A plain, JSON-safe object. A direct
+ *     SDK call creates one and satisfies it immediately; an x402 "402 Payment
+ *     Required" challenge is literally this object serialized onto the wire. So
+ *     it is designed to round-trip to/from an HTTP 402 body with zero loss —
+ *     `parsePaymentRequirement(serializePaymentRequirement(req))` is `req`.
+ *
+ *   Authorization — HOW a settlement is authorized. A discriminated union so the
+ *     settlement core never bakes in "direct SDK signature": today a
+ *     `wallet-signature` (implemented), tomorrow an `x402-payload` (declared,
+ *     not settled yet). This union is the seam that keeps x402 out of the core.
+ *
+ * Nothing here touches the network or the chain — these are the shared data
+ * shapes the SDK produces and the service's protocol-agnostic settlement core
+ * consumes.
+ */
+
+/** The only settlement asset in V1. Named so an x402 challenge carries it verbatim. */
+type SettlementAsset = "USDC";
+/**
+ * The shared payment contract — WHAT must be paid, independent of HOW it was
+ * requested (direct SDK call today, x402 challenge tomorrow).
+ *
+ * Every field is a JSON primitive so the object is byte-stable across an HTTP
+ * 402 body: mint it once, and both the direct path and the x402 path settle the
+ * exact same requirement, idempotent on `id`.
+ */
+interface PaymentRequirement {
+    /** The anchor id (`preq_<ulid>`). Settlement idempotency key + x402 challenge id. */
+    id: string;
+    /** The recipient wallet (the payee). Checksummed or lowercase 0x-address. */
+    payTo: `0x${string}`;
+    /** USD decimal string ("5.00") — same money convention as `pay()`/`enterRound()`. */
+    amount: string;
+    /** Only USDC in V1. */
+    asset: SettlementAsset;
+    /** Which chain settles this requirement. */
+    network: Network;
+    /** Optional free-form terms/memo, echoed on the receipt and in the 402 body. */
+    terms?: string;
+    /** ISO-8601 expiry. A challenge/authorization presented after this is rejected. */
+    expiresAt: string;
+}
+interface CreatePaymentRequirementInput {
+    /** Recipient wallet. */
+    payTo: `0x${string}`;
+    /** USD decimal string ("5.00"). */
+    amount: string;
+    /** Settlement chain. */
+    network: Network;
+    /** Defaults to "USDC". */
+    asset?: SettlementAsset;
+    /** Optional terms/memo. */
+    terms?: string;
+    /** Absolute ISO expiry. Overrides `expiresInMs`. Defaults to now + 15 min. */
+    expiresAt?: string;
+    /** Relative TTL from now, in ms. Ignored if `expiresAt` is set. */
+    expiresInMs?: number;
+    /** Supply for a deterministic id (e.g. to reuse an upstream id); else a `preq_<ulid>` is minted. */
+    id?: string;
+    /** Injectable clock for deterministic tests. */
+    now?: () => Date;
+}
+/**
+ * Build a validated {@link PaymentRequirement}. This is the single producer the
+ * direct primitives (`transfer`/`escrow`/`marketplace`) and — later — the x402
+ * adapter both call, so every requirement on the wire is shaped identically.
+ * Pure: no network, no chain, no id collisions (monotonic ULID).
+ */
+declare function createPaymentRequirement(input: CreatePaymentRequirementInput): PaymentRequirement;
+/**
+ * Serialize a requirement to a plain, JSON-safe object — the exact body an x402
+ * "402 Payment Required" response carries. Undefined optionals are omitted so
+ * the shape is stable across `JSON.stringify` → `JSON.parse` → re-parse.
+ */
+declare function serializePaymentRequirement(req: PaymentRequirement): Record<string, unknown>;
+/**
+ * Parse + validate an untrusted object (an HTTP 402 body, a queue message, a
+ * direct call) back into a {@link PaymentRequirement}. This is the exact decoder
+ * the x402 adapter reuses — it must reject anything malformed with a typed error.
+ */
+declare function parsePaymentRequirement(input: unknown): PaymentRequirement;
+/**
+ * A settlement authorized by a wallet — the ONLY variant implemented in Phase 0.
+ * Covers both signer models the primitives support:
+ *   - server-held NPC/agent wallets (the service signs) and
+ *   - player Base Accounts (the client signs) —
+ * carrying either the settlement `txHash` the client already broadcast, or a
+ * `signature` + `payload` (e.g. EIP-3009 / EIP-5792 batch params) the service
+ * submits. Phase 0 only READS `txHash`; the signed-submit path lands in Phase 1.
+ */
+interface WalletSignatureAuthorization {
+    kind: "wallet-signature";
+    /** The wallet that authorized the move (payer / signer). */
+    from: `0x${string}`;
+    /** A settlement tx the client already broadcast (client-signed path). */
+    txHash?: `0x${string}`;
+    /** An off-chain signature the service submits on the payer's behalf. */
+    signature?: `0x${string}`;
+    /** Opaque protocol-specific authorization data (EIP-5792 calls, EIP-3009, …). */
+    payload?: Record<string, unknown>;
+}
+/**
+ * A settlement authorized by an x402 payment payload (the `X-PAYMENT` header).
+ * DECLARED for the Phase 4 HTTP-402 adapter so the core's type surface is final
+ * now — but NOT settled in Phase 0: `settle()` throws a clear "not implemented
+ * yet" for this variant. This is the seam that keeps x402 out of the core.
+ */
+interface X402PayloadAuthorization {
+    kind: "x402-payload";
+    /** The raw, opaque x402 payment payload decoded from the request. */
+    payload: Record<string, unknown>;
+}
+/** How a settlement is authorized — protocol-agnostic by construction. */
+type Authorization = WalletSignatureAuthorization | X402PayloadAuthorization;
+/** Narrow to the implemented wallet-signature variant. */
+declare function isWalletSignatureAuthorization(auth: Authorization): auth is WalletSignatureAuthorization;
+/** Narrow to the declared-but-unimplemented x402 variant. */
+declare function isX402PayloadAuthorization(auth: Authorization): auth is X402PayloadAuthorization;
+
+/**
+ * x402 helpers — Phase 4 P3 (#153).
+ *
+ * Pure builders for studios that mint their own HTTP 402 responses on Playmos
+ * rails, plus the wire-shape types the SDK client uses for
+ * `playmos.x402.challenge` / `fulfill` / `pay`.
+ *
+ * V1 routes (ADR): `POST /v1/x402/challenges` + `POST /v1/x402/settle` only.
+ * Resource-style URLs are **not** in V1 — `pay({ payTo, amount })` wraps those
+ * two calls. See `docs/design/PHASE-4-X402-ADR.md`.
+ *
+ * Honesty: V1 is an **x402-shaped** API (headers + PaymentRequirement +
+ * Playmos payload rules). Stock TransferWithAuthorization settle is wired
+ * behind #161 Option B (CREATE2 splitter); claim language stays "x402-shaped"
+ * until Gate X X3b is green with a BaseScan hash.
+ */
+
+/** x402-shaped PAYMENT-REQUIRED object (wire matrix §4) with Playmos extensions. */
+interface X402PaymentRequired {
+    scheme: "exact";
+    /** CAIP-2 network id (`eip155:84532` for Base Sepolia). */
+    network: string;
+    /** Atomic USDC (6 dp) as a decimal string. */
+    maxAmountRequired: string;
+    asset: string;
+    payTo: `0x${string}`;
+    /**
+     * Stock-client EIP-712 domain + Playmos seller hint (#161).
+     * `name` / `version` are read from the live USDC token — never hardcoded.
+     */
+    extra?: {
+        name: string;
+        version: string;
+        playmosSeller?: string;
+        playmosRequirementId?: string;
+    };
+    /** Required Playmos extension — settlement idempotency anchor. */
+    playmosRequirementId: string;
+    /** USD decimal string (Playmos money convention). */
+    amount: string;
+    playmosNetwork: Network;
+    expiresAt: string;
+    terms?: string | null;
+    feeBps?: number | null;
+    feeSink?: string | null;
+    /** Economic seller when `payTo` is a CREATE2 clone address (#161). */
+    playmosSeller?: string;
+}
+/** Input to `playmos.x402.challenge(...)` — mints a server-authoritative requirement. */
+interface X402ChallengeInput {
+    /** Recipient wallet. */
+    payTo: `0x${string}`;
+    /** USD decimal string ("0.50"). */
+    amount: string;
+    /**
+     * Money intent. V1 service supports `"transfer"` only today; `marketplace.buy`
+     * is ADR D1 but lands after listing plumbing.
+     */
+    intent?: "transfer" | "marketplace.buy";
+    /** Per-call fee bps (same model as `transfer()`). Default 0. */
+    feeBps?: number;
+    /** Fee destination when feeBps > 0. */
+    feeSink?: `0x${string}`;
+    /** Optional terms/memo. */
+    terms?: string;
+    /** Relative TTL ms (service default 15 min). */
+    expiresInMs?: number;
+    /** Supply a deterministic requirement id; else the service mints `preq_…`. */
+    id?: string;
+}
+/** What `playmos.x402.challenge` resolves to (402 body, already success). */
+interface X402ChallengeResult {
+    requirement: PaymentRequirement;
+    paymentRequired: X402PaymentRequired;
+    feeBps: number;
+    feeSink: string | null;
+}
+/**
+ * Payload modes the Playmos settle path accepts.
+ * Stock modes require PLAYMOS_X402_SPLITTER_FACTORY_ADDRESS (#161 Option B).
+ * Claim "interop" only after Gate X X3b + BaseScan hash.
+ */
+type X402PayloadMode = "server-signer" | "eip3009-auth" | "tx-hash" | "transfer-with-authorization" | "x402-exact-stock";
+/** Authorization body for `playmos.x402.fulfill` / settle. */
+interface X402FulfillAuthorization {
+    mode?: X402PayloadMode;
+    /** Payer address. Optional for server-signer (service fills sandbox signer). */
+    from?: `0x${string}`;
+    /** Optional; if set must match the server-minted challenge (fee authority). */
+    feeBps?: number;
+    feeSink?: `0x${string}`;
+    /** EIP-3009 ReceiveWithAuthorization fields (mode eip3009-auth). */
+    authorization?: Record<string, unknown>;
+    /** Prior broadcast tx (mode tx-hash). */
+    txHash?: `0x${string}`;
+    /** Extra opaque fields forwarded into the payload. */
+    [key: string]: unknown;
+}
+/** Result of `playmos.x402.fulfill` / `pay`. */
+interface X402SettleResult {
+    requirementId: string;
+    status: "settled" | "pending" | "failed" | string;
+    txHash?: `0x${string}` | null;
+    idempotentReplay: boolean;
+    verifiedVia?: string;
+    feeBps: number;
+    fee: string;
+    net: string;
+    requirement: PaymentRequirement;
+    success: boolean;
+}
+/**
+ * One-shot helper input — sequences challenge + settle.
+ *
+ * **Not** a resource URL. ADR locks V1 senior DX as:
+ *   `playmos.x402.pay({ payTo, amount, … })`
+ * wrapping `POST /v1/x402/challenges` then `POST /v1/x402/settle`.
+ * Resource-style `pay({ url })` is deferred V1.1+.
+ */
+interface X402PayInput extends X402ChallengeInput {
+    /**
+     * Settle mode. Defaults to `"server-signer"` (sandbox convenience).
+     * Required on the wire; the SDK always sends an explicit mode (fail-closed).
+     */
+    mode?: X402PayloadMode;
+    /** Payer when not using server-signer default. */
+    from?: `0x${string}`;
+    /** EIP-3009 auth blob when mode is eip3009-auth. */
+    authorization?: Record<string, unknown>;
+    /** Prior tx when mode is tx-hash. */
+    txHash?: `0x${string}`;
+}
+/** Map Playmos network enum → CAIP-2 (wire matrix). */
+declare function networkToCaip2(network: Network): string;
+/**
+ * Playmos {@link PaymentRequirement} → x402-shaped PAYMENT-REQUIRED object.
+ * Mirrors `service/src/routes/x402.ts` `toX402PaymentRequired` so studio-minted
+ * challenges match the official service shape.
+ */
+declare function toX402PaymentRequired(req: PaymentRequirement, extras?: {
+    feeBps?: number;
+    feeSink?: string | null;
+}): X402PaymentRequired;
+/** UTF-8 JSON → base64 (browser + Node). */
+declare function encodePaymentHeader(obj: unknown): string;
+/** Base64 JSON header → object. Throws ConfigError on bad input. */
+declare function decodePaymentHeader(header: string): unknown;
+/**
+ * Studio server helper: build a 402 Payment Required response for a Playmos
+ * {@link PaymentRequirement}. Use this when your API challenges buyers and
+ * Playmos settles via `POST /v1/x402/settle` (or `playmos.x402.fulfill`).
+ *
+ * Does **not** hit the network — pure. For official mint + fee authority, prefer
+ * `playmos.x402.challenge` (server-persisted challenge store).
+ *
+ * @example
+ * ```ts
+ * import { createPaymentRequirement, createX402Challenge } from "@playmos/sdk";
+ *
+ * const requirement = createPaymentRequirement({
+ *   payTo: "0x…", amount: "0.50", network: "base-sepolia",
+ * });
+ * const challenge = createX402Challenge(requirement, { feeBps: 0 });
+ * // res.status(402).set(challenge.headers).json(challenge.body)
+ * ```
+ */
+declare function createX402Challenge(requirement: PaymentRequirement, extras?: {
+    feeBps?: number;
+    feeSink?: string | null;
+}): {
+    status: 402;
+    headers: {
+        "PAYMENT-REQUIRED": string;
+        "Content-Type": string;
+    };
+    body: {
+        error: {
+            code: "payment_required";
+            message: string;
+        };
+        requirement: PaymentRequirement;
+        paymentRequired: X402PaymentRequired;
+        feeBps: number;
+        feeSink: string | null;
+    };
+    paymentRequired: X402PaymentRequired;
+};
+/** Client-side validation shared by challenge / pay (throws before network). */
+declare function validateX402ChallengeInput(input: X402ChallengeInput): {
+    payTo: `0x${string}`;
+    amount: string;
+    intent: "transfer" | "marketplace.buy";
+    feeBps: number;
+    feeSink?: `0x${string}`;
+    terms?: string;
+    expiresInMs?: number;
+    id?: string;
+};
+
 /**
  * The Playmos client — `new Playmos({ apiKey })` → `pay()`, `enterRound()`,
  * `verify()`, `webhooks`, `payouts`, `agents`.
@@ -61,6 +388,46 @@ declare class Playmos {
             url: string;
         }>;
     };
+    /**
+     * `x402` — Phase 4 HTTP 402 / x402-shaped adapter (#153).
+     *
+     * V1 surface (ADR):
+     *   - `challenge` → `POST /v1/x402/challenges` (returns 402; treated as success)
+     *   - `fulfill`   → `POST /v1/x402/settle`
+     *   - `pay`       → challenge then fulfill (senior DX ≤15 lines)
+     *
+     * **Not** resource URLs (`pay({ url })` is V1.1+). **Not** stock third-party
+     * x402 client interop (X3b deferred until #161). Requires `sk_test_` +
+     * Base Sepolia; flag `PLAYMOS_X402_ENABLED` on the service.
+     *
+     * ```ts
+     * const playmos = new Playmos({ apiKey: process.env.PLAYMOS_SK!, network: "base-sepolia" });
+     * const result = await playmos.x402.pay({
+     *   payTo: "0x…",
+     *   amount: "0.50",
+     *   feeBps: 0,
+     * });
+     * // result.txHash → BaseScan
+     * ```
+     */
+    readonly x402: {
+        /**
+         * Mint a server-authoritative PaymentRequirement (HTTP 402).
+         * Fee terms are stored server-side — settle rejects payload disagreement.
+         */
+        challenge: (input: X402ChallengeInput) => Promise<X402ChallengeResult>;
+        /**
+         * Settle a previously minted challenge with an `x402-payload` authorization.
+         * Defaults mode to `server-signer` when omitted (explicit on the wire — fail-closed
+         * materialize still requires mode; the route also defaults for this path).
+         */
+        fulfill: (requirement: PaymentRequirement, authorization?: X402FulfillAuthorization | X402PayloadAuthorization) => Promise<X402SettleResult>;
+        /**
+         * Senior DX: mint challenge + settle in one call.
+         * Wraps challenges + settle only — **not** `pay({ url })` (ADR).
+         */
+        pay: (input: X402PayInput) => Promise<X402SettleResult>;
+    };
     /**
      * Skill/contest **round lifecycle** (issue #13) — closes the enterRound loop.
      *
@@ -185,6 +552,11 @@ declare class Playmos {
         /** Fetch a listing + its on-chain-verified sale status. */
         get: (listingId: string) => Promise<MarketplaceGetResult>;
     };
+    /**
+     * Offline mock payments for this client instance — so `verify(id)` after
+     * `mock: true` pay/enterRound does not hit the live API (#204).
+     */
+    private readonly mockPayments;
     constructor(config: PlaymosConfig);
     /** Connect the player's wallet and return their address. */
     connect(): Promise<`0x${string}`>;
@@ -214,6 +586,7 @@ declare class Playmos {
             identity?: string;
         }>;
     };
+    private rememberMock;
     /** External-studio IAP (1%). Returns a real confirmed Payment with a txHash. */
     pay(input: PayInput): Promise<Payment>;
     /** Playmos-owned skill-game entry (10%, 60/30/10 prize pool). Closes #343. */
@@ -258,6 +631,11 @@ declare class Playmos {
     transfer(input: TransferInput, opts?: TransferConfirmOptions): Promise<TransferResult>;
     /** Verify a payment by the service's on-chain read (spec §6.1). Idempotent. */
     verify(paymentId: string): Promise<VerifyResult>;
+    /**
+     * x402 V1 is Base Sepolia + test keys only (ADR D5). Fail closed before any
+     * network call so mainnet / live keys never silently hit the adapter.
+     */
+    private assertX402Allowed;
     /**
      * Map a server-settled payment (from the `settle: "server"` response) into the
      * SDK's `Payment` shape. The service already signed + confirmed on-chain, so we
@@ -415,132 +793,4 @@ declare function ulid(seedTime?: number): string;
 /** `${prefix}_${ulid()}` — e.g. `pay_01J…`, `entry_01J…`, `idem_01J…`. */
 declare function prefixedId(prefix: string): string;
 
-/**
- * settlement.ts — the x402-ready settlement CORE contract (Phase 0).
- *
- * Two shared shapes every value-movement primitive (`transfer`, `escrow`,
- * `marketplace`) AND the future x402 adapter build on. The whole point of
- * naming them now is that x402 later becomes a thin HTTP-402 adapter with zero
- * rework — see `docs/design/transfer-escrow-marketplace-spec.md` §"Architecture:
- * x402-ready by design".
- *
- *   PaymentRequirement — WHAT must be paid. A plain, JSON-safe object. A direct
- *     SDK call creates one and satisfies it immediately; an x402 "402 Payment
- *     Required" challenge is literally this object serialized onto the wire. So
- *     it is designed to round-trip to/from an HTTP 402 body with zero loss —
- *     `parsePaymentRequirement(serializePaymentRequirement(req))` is `req`.
- *
- *   Authorization — HOW a settlement is authorized. A discriminated union so the
- *     settlement core never bakes in "direct SDK signature": today a
- *     `wallet-signature` (implemented), tomorrow an `x402-payload` (declared,
- *     not settled yet). This union is the seam that keeps x402 out of the core.
- *
- * Nothing here touches the network or the chain — these are the shared data
- * shapes the SDK produces and the service's protocol-agnostic settlement core
- * consumes.
- */
-
-/** The only settlement asset in V1. Named so an x402 challenge carries it verbatim. */
-type SettlementAsset = "USDC";
-/**
- * The shared payment contract — WHAT must be paid, independent of HOW it was
- * requested (direct SDK call today, x402 challenge tomorrow).
- *
- * Every field is a JSON primitive so the object is byte-stable across an HTTP
- * 402 body: mint it once, and both the direct path and the x402 path settle the
- * exact same requirement, idempotent on `id`.
- */
-interface PaymentRequirement {
-    /** The anchor id (`preq_<ulid>`). Settlement idempotency key + x402 challenge id. */
-    id: string;
-    /** The recipient wallet (the payee). Checksummed or lowercase 0x-address. */
-    payTo: `0x${string}`;
-    /** USD decimal string ("5.00") — same money convention as `pay()`/`enterRound()`. */
-    amount: string;
-    /** Only USDC in V1. */
-    asset: SettlementAsset;
-    /** Which chain settles this requirement. */
-    network: Network;
-    /** Optional free-form terms/memo, echoed on the receipt and in the 402 body. */
-    terms?: string;
-    /** ISO-8601 expiry. A challenge/authorization presented after this is rejected. */
-    expiresAt: string;
-}
-interface CreatePaymentRequirementInput {
-    /** Recipient wallet. */
-    payTo: `0x${string}`;
-    /** USD decimal string ("5.00"). */
-    amount: string;
-    /** Settlement chain. */
-    network: Network;
-    /** Defaults to "USDC". */
-    asset?: SettlementAsset;
-    /** Optional terms/memo. */
-    terms?: string;
-    /** Absolute ISO expiry. Overrides `expiresInMs`. Defaults to now + 15 min. */
-    expiresAt?: string;
-    /** Relative TTL from now, in ms. Ignored if `expiresAt` is set. */
-    expiresInMs?: number;
-    /** Supply for a deterministic id (e.g. to reuse an upstream id); else a `preq_<ulid>` is minted. */
-    id?: string;
-    /** Injectable clock for deterministic tests. */
-    now?: () => Date;
-}
-/**
- * Build a validated {@link PaymentRequirement}. This is the single producer the
- * direct primitives (`transfer`/`escrow`/`marketplace`) and — later — the x402
- * adapter both call, so every requirement on the wire is shaped identically.
- * Pure: no network, no chain, no id collisions (monotonic ULID).
- */
-declare function createPaymentRequirement(input: CreatePaymentRequirementInput): PaymentRequirement;
-/**
- * Serialize a requirement to a plain, JSON-safe object — the exact body an x402
- * "402 Payment Required" response carries. Undefined optionals are omitted so
- * the shape is stable across `JSON.stringify` → `JSON.parse` → re-parse.
- */
-declare function serializePaymentRequirement(req: PaymentRequirement): Record<string, unknown>;
-/**
- * Parse + validate an untrusted object (an HTTP 402 body, a queue message, a
- * direct call) back into a {@link PaymentRequirement}. This is the exact decoder
- * the x402 adapter reuses — it must reject anything malformed with a typed error.
- */
-declare function parsePaymentRequirement(input: unknown): PaymentRequirement;
-/**
- * A settlement authorized by a wallet — the ONLY variant implemented in Phase 0.
- * Covers both signer models the primitives support:
- *   - server-held NPC/agent wallets (the service signs) and
- *   - player Base Accounts (the client signs) —
- * carrying either the settlement `txHash` the client already broadcast, or a
- * `signature` + `payload` (e.g. EIP-3009 / EIP-5792 batch params) the service
- * submits. Phase 0 only READS `txHash`; the signed-submit path lands in Phase 1.
- */
-interface WalletSignatureAuthorization {
-    kind: "wallet-signature";
-    /** The wallet that authorized the move (payer / signer). */
-    from: `0x${string}`;
-    /** A settlement tx the client already broadcast (client-signed path). */
-    txHash?: `0x${string}`;
-    /** An off-chain signature the service submits on the payer's behalf. */
-    signature?: `0x${string}`;
-    /** Opaque protocol-specific authorization data (EIP-5792 calls, EIP-3009, …). */
-    payload?: Record<string, unknown>;
-}
-/**
- * A settlement authorized by an x402 payment payload (the `X-PAYMENT` header).
- * DECLARED for the Phase 4 HTTP-402 adapter so the core's type surface is final
- * now — but NOT settled in Phase 0: `settle()` throws a clear "not implemented
- * yet" for this variant. This is the seam that keeps x402 out of the core.
- */
-interface X402PayloadAuthorization {
-    kind: "x402-payload";
-    /** The raw, opaque x402 payment payload decoded from the request. */
-    payload: Record<string, unknown>;
-}
-/** How a settlement is authorized — protocol-agnostic by construction. */
-type Authorization = WalletSignatureAuthorization | X402PayloadAuthorization;
-/** Narrow to the implemented wallet-signature variant. */
-declare function isWalletSignatureAuthorization(auth: Authorization): auth is WalletSignatureAuthorization;
-/** Narrow to the declared-but-unimplemented x402 variant. */
-declare function isX402PayloadAuthorization(auth: Authorization): auth is X402PayloadAuthorization;
-
-export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, PrizeBalance, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, WithdrawResult, type X402PayloadAuthorization, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, ulid };
+export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, PrizeBalance, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, WithdrawResult, type X402ChallengeInput, type X402ChallengeResult, type X402FulfillAuthorization, type X402PayInput, type X402PayloadAuthorization, type X402PayloadMode, type X402PaymentRequired, type X402SettleResult, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, createX402Challenge, decodePaymentHeader, encodePaymentHeader, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, networkToCaip2, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, toX402PaymentRequired, ulid, validateX402ChallengeInput };