@piprail/sdk 1.6.0 → 1.8.0

package/dist/index.d.ts

@@ -3912,6 +3912,18 @@ interface ConfirmInfo {
     /** Block number (EVM) or slot (Solana) as a string — numeric-agnostic. */
     height: string;
 }
+/**
+ * A discovery signer — the bound wallet's address + a message signer. Returned
+ * by {@link ResolvedNetwork.discoverySigner} and used ONLY for discovery
+ * (ownership proofs / SIWX registration), never to move funds. Structurally what
+ * the open-index register helpers consume.
+ */
+interface DiscoverySigner {
+    /** The wallet's own public address (EVM 0x…), declared in a SIWX challenge. */
+    address: string;
+    /** Sign an arbitrary UTF-8 message (EVM: eip191) — for proofs/SIWX only. */
+    signMessage(message: string): Promise<string>;
+}
 /**
  * A driver bound to one concrete network — what the gate and client hold. Each
  * method's error behaviour is fixed by the SDK error standard (see ERRORS.md §5):
@@ -3987,6 +3999,19 @@ interface ResolvedNetwork {
         ready: boolean | 'n/a' | 'unknown';
         reason?: RecipientReason;
     }>;
+    /**
+     * OPTIONAL — a DISCOVERY signer for the bound wallet: its public address plus a
+     * message signer, used only for ownership proofs + SIWX index registration,
+     * NEVER the payment path. `signMessage` returns a chain-native signature string
+     * (EVM: 0x eip191 hex, recoverable with `recoverMessageAddress` — exactly how
+     * x402scan verifies origin ownership). Deliberately optional: a family ships it
+     * only once an open index verifies its signatures — EVM today (the 402 Index
+     * register path needs no signature at all). The client's `register()` skips
+     * signature-gated steps for a family that omits it. The first optional contract
+     * method, so it does NOT trigger the "implement in all families" rule for
+     * REQUIRED methods. Returns `null` if the bound wallet can't sign.
+     */
+    discoverySigner?(wallet: WalletHandle): DiscoverySigner | null;
     /** Verify `ref` satisfies `accept`, RPC-only, in-process. */
     verify(ref: string, accept: X402AcceptEntry): Promise<VerifyResult>;
 }
@@ -4002,6 +4027,101 @@ interface PaymentDriver {
     resolve(opts: ResolveOptions): ResolvedNetwork | null;
 }
 
+/** The open directories PipRail can read from / write to. */
+type DiscoverySource = 'bazaar' | '402index' | 'x402scan';
+/** One payment option as an index reports it — looser than a live `accepts[]`
+ *  entry (indexes are cross-scheme: `exact` is the norm, `onchain-proof` is ours). */
+interface DiscoveredRail {
+    scheme: string;
+    network: string;
+    asset?: string;
+    amount?: string;
+    payTo?: string;
+    symbol?: string;
+}
+/** A resource as returned by an open index, normalized to one shape. */
+interface DiscoveredResource {
+    /** The gated resource URL (what an agent then quotes/pays). */
+    resource: string;
+    /** Which open index surfaced it. */
+    source: DiscoverySource;
+    name?: string;
+    description?: string;
+    category?: string;
+    /** Advertised price in USD, when the index reports one (402 Index). */
+    priceUsd?: number;
+    /** The payment options the index advertises (best-effort, cross-scheme). */
+    rails: DiscoveredRail[];
+}
+/** The result of trying to list a resource on one open index. */
+interface RegisterOutcome {
+    source: DiscoverySource;
+    ok: boolean;
+    /** HTTP status, when a request was made. */
+    status?: number;
+    /** Human note — success summary or the reason it didn't list. */
+    detail?: string;
+    /** A link to the listing, when the index returns one. */
+    listingUrl?: string;
+}
+interface SearchOpenIndexesOptions {
+    /** Free-text query (filtered client-side against name/description/resource). */
+    query?: string;
+    /** Which indexes to read. Default `['bazaar', '402index']` (both free). */
+    sources?: DiscoverySource[];
+    /** Max results per source before dedupe. Default 20. */
+    limit?: number;
+    signal?: AbortSignal;
+}
+/** What a merchant submits to register one resource on the open indexes. */
+interface RegisterInput {
+    url: string;
+    name?: string;
+    description?: string;
+    priceUsd?: number;
+    /** Payment asset symbol, e.g. 'USDC' (402 Index metadata). */
+    asset?: string;
+    /** Payment network slug, e.g. 'base' (402 Index metadata). */
+    network?: string;
+    /** HTTP method the resource answers on. Default 'GET'. */
+    method?: string;
+    /**
+     * Opt-in (default off): add a `via: '@piprail/sdk'` tag to the listing payload. It's the
+     * MERCHANT's listing on a third-party index, so we never tag it by default; and it's
+     * **best-effort** — an index may ignore an unrecognised field. The reliable, always-on
+     * attribution is the `User-Agent` on the request + the `x-generator` stamp in your
+     * emitted `/openapi.json`. Off by default keeps your listing clean and can't be seen as spam.
+     */
+    attribution?: boolean;
+}
+/** Normalize an index's network field to CAIP-2 when we recognise the slug;
+ *  pass a value that's already CAIP-2 (`namespace:reference`) through unchanged.
+ *  An unknown slug returns unchanged (no `:`), which the client treats as
+ *  "unresolved — don't hide it" rather than a confident mismatch. */
+declare function normalizeNetwork(network: string): string;
+/**
+ * Search the open indexes for payable resources, in parallel, and merge them
+ * (deduped by resource URL — the first source in `sources` wins). NEVER throws:
+ * any index that errors, times out, or changes shape contributes `[]`.
+ */
+declare function searchOpenIndexes(opts?: SearchOpenIndexesOptions): Promise<DiscoveredResource[]>;
+/**
+ * Register a resource on **402 Index** — the primary, friction-free path: a
+ * single POST, no auth, no signature, no payment. Searchable within seconds.
+ * Returns a structured outcome; never throws for an HTTP/transport problem.
+ */
+declare function register402Index(input: RegisterInput): Promise<RegisterOutcome>;
+/**
+ * Register on **x402scan** via SIWX (Sign-In-With-X): POST the URL, sign the
+ * EIP-4361 challenge with the merchant's own key, resend with the
+ * `SIGN-IN-WITH-X` header. Facilitator-free, but **Base/Solana-only** and EVM
+ * signing today. EXPERIMENTAL — the open SIWX handshake is a moving convention;
+ * validate against x402scan before relying on it. Never throws.
+ */
+declare function registerX402Scan(input: {
+    url: string;
+}, signer: DiscoverySigner): Promise<RegisterOutcome>;
+
 interface PaymentPolicy {
     /** Per-payment ceiling, human-readable (e.g. '0.10'). Compared using the
      *  token's TRUE decimals, so a server can't understate the price. */
@@ -4315,6 +4435,56 @@ interface PipRailClientOptions {
     /** Logger hook. Default no-op. */
     onEvent?: (event: PipRailEvent) => void;
 }
+/** Options for {@link PipRailClient.discover}. */
+interface DiscoverOptions {
+    /** Free-text query, matched against name/description/resource. */
+    query?: string;
+    /**
+     * Which network's resources to return: a CAIP-2 id (or a chain slug like
+     * `'base'` — normalized to CAIP-2 before matching), `'self'` (the client's
+     * bound chain — the default, so results are payable by THIS client), or
+     * `'any'` (every chain — the agent filters later).
+     */
+    network?: Caip2 | 'self' | 'any' | (string & {});
+    /**
+     * Coarse pre-filter: drop results whose advertised USD price exceeds this.
+     * Results with no advertised price pass through — use `quote()` for the exact
+     * figure before paying.
+     */
+    maxPrice?: number;
+    /** Which open indexes to read. Default `['bazaar', '402index']` (both free). */
+    sources?: DiscoverySource[];
+    /** Max results per source before merge. Default 20. */
+    limit?: number;
+}
+/** Options for {@link PipRailClient.register}. */
+interface RegisterOptions {
+    /** Display name for the listing (defaults to the URL's host). */
+    name?: string;
+    description?: string;
+    /** Advertised price in USD (metadata only). */
+    priceUsd?: number;
+    /** Payment asset symbol, e.g. `'USDC'` (metadata). */
+    asset?: string;
+    /** Payment network slug, e.g. `'base'` (defaults to the client's `chain` when it's a slug). */
+    network?: string;
+    /** HTTP method the resource answers on. Default 'GET'. */
+    method?: string;
+    /**
+     * Which open indexes to list on. Default `['402index']` — no auth, no
+     * signature. Add `'x402scan'` for the SIWX path (needs an EVM `discoverySigner`
+     * and a Base/Solana rail). `'bazaar'` can't be written to (facilitator-only).
+     */
+    targets?: DiscoverySource[];
+    /**
+     * Opt-in (default off): tag the listing as built with PipRail (`via: '@piprail/sdk'`).
+     * It's a third-party listing, so we never tag it by default — and it's best-effort (the
+     * index may ignore the field). The always-on, reliable attribution is the request
+     * `User-Agent` + the `x-generator` stamp in your emitted `/openapi.json` (see
+     * `buildOpenApi`). Leave off unless you specifically want the listing tagged.
+     */
+    attribution?: boolean;
+}
 declare class PipRailClient {
     private readonly opts;
     private readonly maxRetries;
@@ -4390,6 +4560,38 @@ declare class PipRailClient {
      * resource is trivially "affordable"). No funds move.
      */
     canAfford(url: string, init?: RequestInit): Promise<boolean>;
+    /**
+     * Find payable resources on the OPEN x402 indexes — WITHOUT paying. Reads the
+     * free indexes (CDP Bazaar + 402 Index by default), merges + dedupes them, and
+     * by default returns only resources payable on THIS client's chain
+     * (`network: 'self'`). Each result carries its advertised `rails[]`; feed a
+     * chosen `resource` straight into `quote()` → `planPayment()` → `fetch()`.
+     *
+     * Nothing PipRail-hosted: these are third-party open directories. Never throws
+     * for a read problem — an index that's down or changed simply contributes
+     * nothing. Honest caveat: index results are cross-scheme (mostly the
+     * mainstream `exact` scheme); `fetch()` pays only `onchain-proof` rails
+     * directly (pay `exact` resources with the experimental `drivers/evm/exact.ts`).
+     */
+    discover(opts?: DiscoverOptions): Promise<DiscoveredResource[]>;
+    /**
+     * List a resource you run on the OPEN x402 registries, so agents can find it.
+     * Default target is **402 Index** — one POST, no auth, no signature, no payment
+     * (searchable within seconds). Add `'x402scan'` to also register via SIWX (one
+     * wallet signature; EVM + a Base/Solana rail). Returns one {@link RegisterOutcome}
+     * per target — a target the chain can't satisfy comes back `{ ok:false, detail }`,
+     * never a throw. An explicit, developer-invoked action; it moves no funds, and
+     * nothing is PipRail-hosted — you're listing on third-party open directories.
+     */
+    register(url: string, opts?: RegisterOptions): Promise<RegisterOutcome[]>;
+    /**
+     * The discovery signer for the bound wallet (its address + a message signer),
+     * or `null` if the chain family doesn't support it (EVM does today). For
+     * discovery only — ownership proofs (sign the bare origin string and pass it to
+     * `buildOpenApi({ ownershipProofs })`) and SIWX registration. Never signs a
+     * payment.
+     */
+    discoverySigner(): Promise<DiscoverySigner | null>;
     /**
      * Lower-level: drive any HTTP method through the 402 flow.
      *
@@ -4434,6 +4636,25 @@ declare class PipRailClient {
  */
 declare function planAcross(clients: PipRailClient[], url: string, init?: RequestInit): Promise<PaymentPlan | null>;
 
+/**
+ * MCP-style tool annotations — optional, advisory hints that let an MCP client or
+ * agent reason about a tool's *nature* (is it safe to call freely? does it move
+ * value?). They mirror the MCP spec's `ToolAnnotations`. NOTE: hints only — a
+ * client must never make a security decision solely on these; the spend policy is
+ * the real boundary.
+ */
+interface ToolAnnotations {
+    /** Human-friendly title for the tool. */
+    title?: string;
+    /** True when the tool only READS — no state change, no funds moved. */
+    readOnlyHint?: boolean;
+    /** True when the tool may move value or do something not easily undone (only meaningful when not read-only). */
+    destructiveHint?: boolean;
+    /** True when calling repeatedly with the same args has no additional effect. */
+    idempotentHint?: boolean;
+    /** True when the tool reaches the open world — external indexes, chains, or arbitrary URLs. */
+    openWorldHint?: boolean;
+}
 /** A framework-agnostic tool definition an agent runtime can register. */
 interface AgentTool {
     /** Unique tool name (snake_case, namespaced `piprail_…`). */
@@ -4442,21 +4663,181 @@ interface AgentTool {
     description: string;
     /** JSON Schema (draft-07 object) describing the arguments. */
     parameters: Record<string, unknown>;
+    /** Advisory MCP-style hints about the tool's nature (read-only, value-moving, …). */
+    annotations?: ToolAnnotations;
     /** Execute the tool. Returns a JSON-serialisable result. */
     invoke: (args: Record<string, unknown>) => Promise<unknown>;
 }
 /**
- * Three tools wrapping a configured {@link PipRailClient}:
+ * Five tools wrapping a configured {@link PipRailClient}:
+ *   - `piprail_discover(query?)` — FIND payable resources on the open x402
+ *     indexes, WITHOUT paying (the phone book — solves "what can I buy?").
  *   - `piprail_quote_payment(url)` — price a gated URL WITHOUT paying.
  *   - `piprail_plan_payment(url)` — check you CAN pay (balance + gas + recipient
  *     readiness) across every rail the URL offers, WITHOUT paying.
  *   - `piprail_pay_request(url, method?, body?)` — pay if needed and return the result.
+ *   - `piprail_register(url, …)` — LIST a resource you run on the open indexes so
+ *     other agents can find it (402 Index, no signature).
  *
  * A policy/approval refusal comes back as a structured `{ declined: true, reason }`
  * (not a thrown error), so the model can reason about it instead of crashing.
  */
 declare function paymentTools(client: PipRailClient): AgentTool[];
 
+/**
+ * Discovery — make a gated resource FINDABLE, by emitting the open-standard
+ * artifacts a crawler/index reads. PURE: this file turns the config a gate
+ * already has into static metadata; it does NO network I/O and imports NO chain
+ * library (protocol layer — STANDARDS §1). The runtime side (registering with /
+ * searching the open indexes) lives in `indexes.ts` + the client.
+ *
+ * Three artifacts, three open conventions (see `.claude/research/x402-discovery.md`):
+ *   - OpenAPI-first `/openapi.json` (`x-payment-info` per op) — the live convention
+ *     the open indexes parse today (x402scan via `@agentcash/discovery`).
+ *   - `/.well-known/x402` origin file — x402scan's legacy bulk-register format.
+ *   - `_x402` DNS TXT line — the (experimental) DNS pointer draft.
+ *
+ * A merchant serves the emitted file on THEIR OWN origin (a static asset — no
+ * backend). Nothing is PipRail-hosted. All opt-in; the pay path is untouched.
+ *
+ * Honesty note (held everywhere): there is no single ratified discovery
+ * standard — OpenAPI-first is an emerging multi-vendor convention. Emit it, but
+ * treat it as a moving target. And PipRail's own rails use `scheme:
+ * 'onchain-proof'`; a merchant who also wants to be USEFULLY listed on the open
+ * indexes should additionally offer a standard `exact` USDC rail on Base/Solana.
+ */
+
+/**
+ * The static (nonce-free) shape of one payment option — the discoverable part of
+ * an `X402AcceptEntry`. A live challenge adds a single-use `nonce`; discovery
+ * metadata is long-lived, so it carries none. Produced by `gate.describe()`,
+ * consumed by every emitter below.
+ */
+interface PaymentRail {
+    scheme: 'onchain-proof';
+    network: Caip2;
+    asset: AssetId;
+    payTo: AddressId;
+    /** Amount in the token's base units (already scaled by decimals). */
+    amount: string;
+    /** Human-readable amount, e.g. "0.05". */
+    amountFormatted: string;
+    decimals: number;
+    symbol?: string;
+    maxTimeoutSeconds: number;
+}
+/** One discoverable resource: its URL, how to call it, and how to pay it. */
+interface ResourceDescription {
+    /** The full URL of the gated resource. */
+    url: string;
+    /** HTTP method the resource answers on. Default 'GET'. */
+    method?: string;
+    /** Human description (shown to agents browsing an index). */
+    description?: string;
+    /** The payment options the gate offers (its resolved `accepts`, nonce-free). */
+    accepts: PaymentRail[];
+}
+/** Shared input for the emitters that describe a whole origin. */
+interface ManifestInput {
+    /** The origin the merchant controls, e.g. 'https://api.example.com' (no path). */
+    origin: string;
+    /** The discoverable resources at that origin. */
+    resources: ResourceDescription[];
+    /**
+     * Optional ownership proofs — each a signature of the BARE ORIGIN STRING by a
+     * `payTo` key (EVM: eip191 hex). A trust badge on indexes that verify it
+     * (x402scan: `recoverMessageAddress(origin, sig) === payTo`); never required to
+     * be listed. Produce one with the driver's `signMessage(wallet, origin)`.
+     */
+    ownershipProofs?: string[];
+    /** OpenAPI `info.title`. Default 'PipRail x402 resources'. */
+    title?: string;
+    /** OpenAPI `info.version`. Default '1.0.0'. */
+    version?: string;
+    /**
+     * Stamp the doc with a `x-generator: "@piprail/sdk"` attribution — a standard,
+     * unobtrusive "built with" marker (à la Swagger/Hugo) that rides along wherever
+     * an index crawls your `/openapi.json`, so the tech spreads as you get found.
+     * Default **true**; set `false` to omit it entirely. It's metadata only — it
+     * changes nothing about how the resource is paid or listed.
+     */
+    attribution?: boolean;
+}
+/** What `x-generator` stamps when attribution is on — see {@link ManifestInput.attribution}. */
+declare const GENERATOR = "@piprail/sdk \u00B7 https://piprail.com";
+/** A minimal, valid OpenAPI 3.1 document carrying `x-payment-info` per paid op. */
+interface OpenApiDocument {
+    openapi: '3.1.0';
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    /** "Built with @piprail/sdk" attribution (unless `attribution: false`). */
+    'x-generator'?: string;
+    /** Provenance block the open indexes read (x402scan / agentcash). */
+    'x-agentcash-provenance'?: {
+        ownershipProofs: string[];
+    };
+}
+interface OpenApiOperation {
+    summary?: string;
+    responses: Record<string, {
+        description: string;
+    }>;
+    /** The discovery payload an x402 index reads: the rails for this operation. */
+    'x-payment-info': {
+        x402Version: 2;
+        accepts: PaymentRail[];
+        /** Bazaar-style input schema marker so a strict index doesn't "skip" the op. */
+        bazaar: {
+            discoverable: true;
+        };
+    };
+}
+/** x402scan's legacy origin file (`/.well-known/x402`). */
+interface WellKnownX402 {
+    version: 1;
+    resources: string[];
+    ownershipProofs?: string[];
+}
+/** The `_x402` DNS TXT pointer record (experimental draft). */
+interface X402DnsRecord {
+    name: string;
+    type: 'TXT';
+    value: string;
+}
+/**
+ * Build a `/openapi.json` document — the OpenAPI-first discovery doc the live
+ * open indexes parse. One path per resource (grouped by pathname, keyed by
+ * method), each paid operation carrying `x-payment-info` with the resource's
+ * rails. Ownership proofs (if any) ride at `x-agentcash-provenance`.
+ *
+ * The merchant serves the result at `https://<origin>/openapi.json`. Pure — no
+ * network, no chain library, fully deterministic.
+ */
+declare function buildOpenApi(input: ManifestInput): OpenApiDocument;
+/**
+ * Build the `/.well-known/x402` origin file (x402scan's legacy bulk-register
+ * format): the list of discoverable resource URLs + optional ownership proofs.
+ * `/openapi.json` is the primary doc; this is a compatibility breadcrumb.
+ */
+declare function buildWellKnownX402(input: ManifestInput): WellKnownX402;
+/**
+ * Build the `_x402` DNS TXT record (experimental draft) that POINTS at a
+ * discovery doc. `host` is the exact host the agent talks to (no inheritance);
+ * `discoveryUrl` is the HTTPS manifest (typically `https://<origin>/openapi.json`).
+ * Returns the record name + value to paste into the zone — PipRail never touches DNS.
+ */
+declare function buildX402DnsTxt(input: {
+    host: string;
+    discoveryUrl: string;
+    descriptor?: string;
+}): X402DnsRecord;
+
 /**
  * The accept side: gate any endpoint behind a payment with one function.
  *
@@ -4584,6 +4965,15 @@ interface PaymentGate {
     }>;
     /** Verify an incoming `payment-signature` header value. */
     verify(paymentSignature: string | string[] | undefined): Promise<VerifyPaymentResult>;
+    /**
+     * Describe this gate's payment options as static, nonce-free discovery
+     * metadata — feed it to the emitters in `discovery.ts` (`buildOpenApi` /
+     * `buildWellKnownX402`) to make the resource findable. Reuses the same
+     * resolved options the challenge is built from (so a `0x…` payTo / decimals
+     * are already correct); unlike `challenge()`, it mints no nonce, because
+     * discovery metadata is long-lived. Read-only — moves nothing on-chain.
+     */
+    describe(resourceUrl?: string): Promise<ResourceDescription>;
 }
 /**
  * Framework-agnostic core. Build one gate per gated resource and reuse it
@@ -4927,4 +5317,4 @@ declare function encodeXPaymentHeader(input: {
     x402Version?: number;
 }): string;
 
-export { type AcceptOption, type AddressId, type AgentTool, type AlgorandToken, type AptosToken, type AssetId, type BuildExactParams, CHAINS, type Caip2, type ChainFamily, type ChainInput, type ChainName, type ChainPreset, type ChainSelector, type ConfirmInfo, ConfirmationTimeoutError, type CostEstimate, EIP3009_TYPES, EXACT_NETWORK_SLUGS, type EvmToken, type ExactAccept, type ExactAuthorization, type ExpressLikeMiddleware, type ExpressLikeNext, type ExpressLikeRequest, type ExpressLikeResponse, InsufficientFundsError, InvalidEnvelopeError, MaxRetriesExceededError, MissingDriverError, type NearToken, NoCompatibleAcceptError, NonReplayableBodyError, type PayBlocker, type PayOption, type PayWarning, PaymentDeclinedError, type PaymentDriver, type PaymentGate, type PaymentIntent, type PaymentPlan, type PaymentPolicy, PaymentTimeoutError, PipRailClient, type PipRailClientOptions, type PipRailCostQuote, PipRailError, type PipRailEvent, type PipRailQuote, type PolicyDecision, RecipientNotReadyError, type RecipientReason, type RequirePaymentOptions, type ResolveOptions, type ResolvedChain, type ResolvedNetwork, type ResolvedToken, type SolanaToken, type SpendAssetTotal, type SpendRecord, type SpendSummary, type StellarToken, type SuiToken, type TokenInfo, type TokenInput, type TonToken, type TronToken, UnknownTokenError, UnsupportedNetworkError, type VerifyErrorCode, type VerifyPaymentResult, type VerifyResult, type WalletBalance, type WalletHandle, type WalletInput, WrongChainError, WrongFamilyError, type X402AcceptEntry, type X402Challenge, type X402InvalidBody, type X402PaymentSignature, type X402Receipt, type X402ResourceObject, type XrplToken, buildChallengeHeader, buildExactAuthorization, buildReceiptHeader, buildSignatureHeader, chainIdForExactNetwork, createPaymentGate, encodeXPaymentHeader, evaluatePolicy, parseChallenge, parseExactRequirements, parseReceipt, parseSignatureHeader, paymentTools, pickAccept, planAcross, registerDriver, requirePayment, resolveChain, toInsufficientFundsError, toInvalidBody };
+export { type AcceptOption, type AddressId, type AgentTool, type AlgorandToken, type AptosToken, type AssetId, type BuildExactParams, CHAINS, type Caip2, type ChainFamily, type ChainInput, type ChainName, type ChainPreset, type ChainSelector, type ConfirmInfo, ConfirmationTimeoutError, type CostEstimate, type DiscoverOptions, type DiscoveredRail, type DiscoveredResource, type DiscoverySigner, type DiscoverySource, EIP3009_TYPES, EXACT_NETWORK_SLUGS, type EvmToken, type ExactAccept, type ExactAuthorization, type ExpressLikeMiddleware, type ExpressLikeNext, type ExpressLikeRequest, type ExpressLikeResponse, GENERATOR, InsufficientFundsError, InvalidEnvelopeError, type ManifestInput, MaxRetriesExceededError, MissingDriverError, type NearToken, NoCompatibleAcceptError, NonReplayableBodyError, type OpenApiDocument, type OpenApiOperation, type PayBlocker, type PayOption, type PayWarning, PaymentDeclinedError, type PaymentDriver, type PaymentGate, type PaymentIntent, type PaymentPlan, type PaymentPolicy, type PaymentRail, PaymentTimeoutError, PipRailClient, type PipRailClientOptions, type PipRailCostQuote, PipRailError, type PipRailEvent, type PipRailQuote, type PolicyDecision, RecipientNotReadyError, type RecipientReason, type RegisterInput, type RegisterOptions, type RegisterOutcome, type RequirePaymentOptions, type ResolveOptions, type ResolvedChain, type ResolvedNetwork, type ResolvedToken, type ResourceDescription, type SearchOpenIndexesOptions, type SolanaToken, type SpendAssetTotal, type SpendRecord, type SpendSummary, type StellarToken, type SuiToken, type TokenInfo, type TokenInput, type TonToken, type ToolAnnotations, type TronToken, UnknownTokenError, UnsupportedNetworkError, type VerifyErrorCode, type VerifyPaymentResult, type VerifyResult, type WalletBalance, type WalletHandle, type WalletInput, type WellKnownX402, WrongChainError, WrongFamilyError, type X402AcceptEntry, type X402Challenge, type X402DnsRecord, type X402InvalidBody, type X402PaymentSignature, type X402Receipt, type X402ResourceObject, type XrplToken, buildChallengeHeader, buildExactAuthorization, buildOpenApi, buildReceiptHeader, buildSignatureHeader, buildWellKnownX402, buildX402DnsTxt, chainIdForExactNetwork, createPaymentGate, encodeXPaymentHeader, evaluatePolicy, normalizeNetwork, parseChallenge, parseExactRequirements, parseReceipt, parseSignatureHeader, paymentTools, pickAccept, planAcross, register402Index, registerDriver, registerX402Scan, requirePayment, resolveChain, searchOpenIndexes, toInsufficientFundsError, toInvalidBody };