@t402/core 2.3.0 → 2.4.0

package/dist/esm/mechanisms-C7yK91d4.d.mts

@@ -0,0 +1,1126 @@
+import { z } from 'zod';
+
+type PaymentRequirementsV1 = {
+    scheme: string;
+    network: Network;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    mimeType: string;
+    outputSchema: Record<string, unknown>;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    asset: string;
+    extra: Record<string, unknown>;
+};
+type PaymentRequiredV1 = {
+    t402Version: 1;
+    error?: string;
+    accepts: PaymentRequirementsV1[];
+};
+type PaymentPayloadV1 = {
+    t402Version: 1;
+    scheme: string;
+    network: Network;
+    payload: Record<string, unknown>;
+};
+type VerifyRequestV1 = {
+    paymentPayload: PaymentPayloadV1;
+    paymentRequirements: PaymentRequirementsV1;
+};
+type SettleRequestV1 = {
+    paymentPayload: PaymentPayloadV1;
+    paymentRequirements: PaymentRequirementsV1;
+};
+type SettleResponseV1 = {
+    success: boolean;
+    errorReason?: string;
+    payer?: string;
+    transaction: string;
+    network: Network;
+};
+type SupportedResponseV1 = {
+    kinds: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }[];
+};
+
+interface ResourceServerExtension {
+    key: string;
+    enrichDeclaration?: (declaration: unknown, transportContext: unknown) => unknown;
+}
+
+/**
+ * A2A (Agent-to-Agent) Transport Types
+ *
+ * Implements t402 payment flows over the Agent-to-Agent protocol
+ * using JSON-RPC messages and task-based state management.
+ *
+ * @see https://github.com/google-a2a/a2a-t402/v0.1
+ */
+
+/**
+ * Payment status values used in A2A metadata
+ */
+type A2APaymentStatus = "payment-required" | "payment-rejected" | "payment-submitted" | "payment-verified" | "payment-completed" | "payment-failed";
+/**
+ * A2A task states that correspond to payment states
+ */
+type A2ATaskState = "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+/**
+ * A2A message part - text content
+ */
+interface A2ATextPart {
+    kind: "text";
+    text: string;
+}
+/**
+ * A2A message part - file content
+ */
+interface A2AFilePart {
+    kind: "file";
+    file: {
+        name?: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+}
+/**
+ * A2A message part - data content
+ */
+interface A2ADataPart {
+    kind: "data";
+    data: Record<string, unknown>;
+}
+type A2AMessagePart = A2ATextPart | A2AFilePart | A2ADataPart;
+/**
+ * A2A payment metadata fields
+ */
+interface A2APaymentMetadata {
+    /** Current payment status */
+    "t402.payment.status"?: A2APaymentStatus;
+    /** Payment requirements (when status is payment-required) */
+    "t402.payment.required"?: PaymentRequired;
+    /** Payment payload (when status is payment-submitted) */
+    "t402.payment.payload"?: PaymentPayload;
+    /** Settlement receipts (when status is payment-completed or payment-failed) */
+    "t402.payment.receipts"?: SettleResponse[];
+    /** Error code (when status is payment-failed) */
+    "t402.payment.error"?: string;
+}
+/**
+ * A2A message with payment metadata
+ */
+interface A2AMessage {
+    kind: "message";
+    messageId?: string;
+    role: "user" | "agent";
+    parts: A2AMessagePart[];
+    metadata?: A2APaymentMetadata & Record<string, unknown>;
+}
+/**
+ * A2A artifact (output from completed task)
+ */
+interface A2AArtifact {
+    kind: string;
+    name?: string;
+    mimeType?: string;
+    data?: string;
+    uri?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A2A task status
+ */
+interface A2ATaskStatus {
+    state: A2ATaskState;
+    message?: A2AMessage;
+    timestamp?: string;
+}
+/**
+ * A2A task
+ */
+interface A2ATask {
+    kind: "task";
+    id: string;
+    sessionId?: string;
+    status: A2ATaskStatus;
+    artifacts?: A2AArtifact[];
+    history?: A2AMessage[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A2A JSON-RPC request
+ */
+interface A2ARequest<T = unknown> {
+    jsonrpc: "2.0";
+    method: string;
+    id: string | number;
+    params?: T;
+}
+/**
+ * A2A JSON-RPC response
+ */
+interface A2AResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: T;
+    error?: A2AError;
+}
+/**
+ * A2A JSON-RPC error
+ */
+interface A2AError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * A2A extension declaration
+ */
+interface A2AExtension {
+    uri: string;
+    description?: string;
+    required?: boolean;
+}
+/**
+ * A2A agent capabilities
+ */
+interface A2ACapabilities {
+    streaming?: boolean;
+    pushNotifications?: boolean;
+    stateTransitionHistory?: boolean;
+    extensions?: A2AExtension[];
+}
+/**
+ * A2A agent card (service advertisement)
+ */
+interface A2AAgentCard {
+    name: string;
+    description?: string;
+    url: string;
+    provider?: {
+        organization?: string;
+        url?: string;
+    };
+    version?: string;
+    documentationUrl?: string;
+    capabilities?: A2ACapabilities;
+    authentication?: {
+        schemes: string[];
+        credentials?: string;
+    };
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    skills?: A2ASkill[];
+}
+/**
+ * A2A skill definition
+ */
+interface A2ASkill {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    examples?: string[];
+    inputModes?: string[];
+    outputModes?: string[];
+}
+/**
+ * T402 A2A extension URI
+ */
+declare const T402_A2A_EXTENSION_URI = "https://github.com/google-a2a/a2a-t402/v0.1";
+/**
+ * HTTP header for A2A extension activation
+ */
+declare const A2A_EXTENSIONS_HEADER = "X-A2A-Extensions";
+/**
+ * Check if a task is in a payment-required state
+ */
+declare function isPaymentRequired(task: A2ATask): boolean;
+/**
+ * Check if a task has completed payment
+ */
+declare function isPaymentCompleted(task: A2ATask): boolean;
+/**
+ * Check if a task has failed payment
+ */
+declare function isPaymentFailed(task: A2ATask): boolean;
+/**
+ * Extract payment requirements from a task
+ */
+declare function getPaymentRequired(task: A2ATask): PaymentRequired | undefined;
+/**
+ * Extract payment receipts from a task
+ */
+declare function getPaymentReceipts(task: A2ATask): SettleResponse[] | undefined;
+/**
+ * Create a payment-required message
+ */
+declare function createPaymentRequiredMessage(paymentRequired: PaymentRequired, text?: string): A2AMessage;
+/**
+ * Create a payment submission message
+ */
+declare function createPaymentSubmissionMessage(paymentPayload: PaymentPayload, text?: string): A2AMessage;
+/**
+ * Create a payment completed message
+ */
+declare function createPaymentCompletedMessage(receipts: SettleResponse[], text?: string): A2AMessage;
+/**
+ * Create a payment failed message
+ */
+declare function createPaymentFailedMessage(receipts: SettleResponse[], errorCode: string, text?: string): A2AMessage;
+/**
+ * Create a T402 extension declaration for agent cards
+ */
+declare function createT402Extension(required?: boolean): A2AExtension;
+
+/**
+ * Up-To Scheme Types
+ *
+ * The `upto` scheme authorizes transfer of up to a maximum amount,
+ * enabling usage-based billing where the final settlement amount
+ * is determined by actual usage.
+ *
+ * @example
+ * ```typescript
+ * // Client authorizes up to $1.00
+ * const requirements: UptoPaymentRequirements = {
+ *   scheme: 'upto',
+ *   network: 'eip155:8453',
+ *   maxAmount: '1000000',  // $1.00 in USDC
+ *   minAmount: '10000',    // $0.01 minimum
+ *   asset: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   payTo: '0x...',
+ *   maxTimeoutSeconds: 300,
+ *   extra: {
+ *     unit: 'token',
+ *     unitPrice: '100',
+ *   },
+ * };
+ *
+ * // Server settles for actual usage ($0.15)
+ * const settlement: UptoSettlement = {
+ *   settleAmount: '150000',
+ *   usageDetails: {
+ *     tokensGenerated: 1500,
+ *     unitPrice: '100',
+ *   },
+ * };
+ * ```
+ */
+
+/**
+ * Extended payment requirements for the upto scheme.
+ */
+interface UptoPaymentRequirements extends Omit<PaymentRequirements, "scheme" | "amount"> {
+    /** Scheme identifier - always 'upto' */
+    scheme: "upto";
+    /** Network identifier (CAIP-2 format) */
+    network: Network;
+    /** Maximum amount the client authorizes (in smallest denomination) */
+    maxAmount: string;
+    /** Minimum settlement amount (prevents dust payments) */
+    minAmount?: string;
+    /** Asset contract address or identifier */
+    asset: string;
+    /** Recipient address */
+    payTo: string;
+    /** Maximum time in seconds before payment expires */
+    maxTimeoutSeconds: number;
+    /** Additional scheme-specific data */
+    extra: UptoExtra;
+}
+/**
+ * Extra fields specific to the upto scheme.
+ */
+interface UptoExtra extends Record<string, unknown> {
+    /** Billing unit (e.g., 'token', 'request', 'second', 'byte') */
+    unit?: string;
+    /** Price per unit in smallest denomination */
+    unitPrice?: string;
+    /** EIP-712 domain name (for EVM) */
+    name?: string;
+    /** EIP-712 domain version (for EVM) */
+    version?: string;
+    /** Router contract address (for EVM) */
+    routerAddress?: string;
+}
+/**
+ * Base payload structure for upto scheme.
+ */
+interface UptoPayloadBase {
+    /** Unique nonce to prevent replay attacks */
+    nonce: string;
+}
+/**
+ * EVM-specific upto payload using EIP-2612 Permit.
+ */
+interface UptoEvmPayload extends UptoPayloadBase {
+    /** EIP-2612 permit signature components */
+    signature: {
+        v: number;
+        r: `0x${string}`;
+        s: `0x${string}`;
+    };
+    /** Permit authorization parameters */
+    authorization: {
+        /** Token owner address */
+        owner: `0x${string}`;
+        /** Spender address (router contract) */
+        spender: `0x${string}`;
+        /** Maximum authorized value */
+        value: string;
+        /** Permit deadline (unix timestamp) */
+        deadline: string;
+        /** Permit nonce (from token contract) */
+        nonce: number;
+    };
+}
+/**
+ * Alternative EVM payload with combined signature.
+ */
+interface UptoEvmPayloadCompact extends UptoPayloadBase {
+    /** Combined EIP-2612 permit signature */
+    signature: `0x${string}`;
+    /** Permit authorization parameters */
+    authorization: {
+        owner: `0x${string}`;
+        spender: `0x${string}`;
+        value: string;
+        deadline: string;
+        nonce: number;
+    };
+}
+/**
+ * Settlement request for upto scheme.
+ */
+interface UptoSettlement {
+    /** Actual amount to settle (must be <= maxAmount) */
+    settleAmount: string;
+    /** Optional usage details for auditing */
+    usageDetails?: UptoUsageDetails;
+}
+/**
+ * Usage details for settlement auditing.
+ */
+interface UptoUsageDetails {
+    /** Number of units consumed */
+    unitsConsumed?: number;
+    /** Price per unit used */
+    unitPrice?: string;
+    /** Type of unit */
+    unitType?: string;
+    /** Start timestamp of usage period */
+    startTime?: number;
+    /** End timestamp of usage period */
+    endTime?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Settlement response for upto scheme.
+ */
+interface UptoSettlementResponse {
+    /** Whether settlement was successful */
+    success: boolean;
+    /** Transaction hash (if on-chain) */
+    transactionHash?: string;
+    /** Actual amount settled */
+    settledAmount: string;
+    /** Maximum amount that was authorized */
+    maxAmount: string;
+    /** Block number (if on-chain) */
+    blockNumber?: number;
+    /** Gas used (if on-chain) */
+    gasUsed?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Validation result for upto payment.
+ */
+interface UptoValidationResult {
+    /** Whether the payment is valid */
+    isValid: boolean;
+    /** Reason if invalid */
+    invalidReason?: string;
+    /** Validated maximum amount */
+    validatedMaxAmount?: string;
+    /** Payer address */
+    payer?: string;
+    /** Expiration timestamp */
+    expiresAt?: number;
+}
+/**
+ * Type guard for UptoPaymentRequirements.
+ *
+ * @param requirements - The value to check
+ * @returns True if the value is UptoPaymentRequirements
+ */
+declare function isUptoPaymentRequirements(requirements: unknown): requirements is UptoPaymentRequirements;
+/**
+ * Type guard for UptoEvmPayload.
+ *
+ * @param payload - The value to check
+ * @returns True if the value is UptoEvmPayload
+ */
+declare function isUptoEvmPayload(payload: unknown): payload is UptoEvmPayload;
+/**
+ * Constants for upto scheme.
+ */
+declare const UPTO_SCHEME: "upto";
+declare const UPTO_DEFAULTS: {
+    /** Default minimum settlement amount (prevents dust) */
+    readonly MIN_AMOUNT: "1000";
+    /** Default maximum timeout in seconds (5 minutes) */
+    readonly MAX_TIMEOUT_SECONDS: 300;
+    /** Supported billing units */
+    readonly UNITS: readonly ["token", "request", "second", "minute", "byte", "kb", "mb"];
+};
+type UptoUnit = (typeof UPTO_DEFAULTS.UNITS)[number];
+
+/**
+ * Standardized T402 error codes returned by the facilitator API.
+ * Error codes follow the format T402-XYYY where X is the category (1-8)
+ * and YYY is the specific error within that category.
+ */
+declare const ERR_INVALID_REQUEST: "T402-1001";
+declare const ERR_MISSING_PAYLOAD: "T402-1002";
+declare const ERR_MISSING_REQUIREMENTS: "T402-1003";
+declare const ERR_INVALID_PAYLOAD: "T402-1004";
+declare const ERR_INVALID_REQUIREMENTS: "T402-1005";
+declare const ERR_INVALID_SIGNATURE: "T402-1006";
+declare const ERR_INVALID_NETWORK: "T402-1007";
+declare const ERR_INVALID_SCHEME: "T402-1008";
+declare const ERR_INVALID_AMOUNT: "T402-1009";
+declare const ERR_INVALID_ADDRESS: "T402-1010";
+declare const ERR_EXPIRED_PAYMENT: "T402-1011";
+declare const ERR_INVALID_NONCE: "T402-1012";
+declare const ERR_INSUFFICIENT_AMOUNT: "T402-1013";
+declare const ERR_INVALID_IDEMPOTENCY_KEY: "T402-1014";
+declare const ERR_SIGNATURE_EXPIRED: "T402-1015";
+declare const ERR_INTERNAL: "T402-2001";
+declare const ERR_DATABASE_UNAVAILABLE: "T402-2002";
+declare const ERR_CACHE_UNAVAILABLE: "T402-2003";
+declare const ERR_RPC_UNAVAILABLE: "T402-2004";
+declare const ERR_RATE_LIMITED: "T402-2005";
+declare const ERR_SERVICE_UNAVAILABLE: "T402-2006";
+declare const ERR_VERIFICATION_FAILED: "T402-3001";
+declare const ERR_SETTLEMENT_FAILED: "T402-3002";
+declare const ERR_INSUFFICIENT_BALANCE: "T402-3003";
+declare const ERR_ALLOWANCE_INSUFFICIENT: "T402-3004";
+declare const ERR_PAYMENT_MISMATCH: "T402-3005";
+declare const ERR_DUPLICATE_PAYMENT: "T402-3006";
+declare const ERR_SETTLEMENT_PENDING: "T402-3007";
+declare const ERR_SETTLEMENT_TIMEOUT: "T402-3008";
+declare const ERR_NONCE_REPLAY: "T402-3009";
+declare const ERR_IDEMPOTENCY_CONFLICT: "T402-3010";
+declare const ERR_IDEMPOTENCY_UNAVAILABLE: "T402-3011";
+declare const ERR_PREVIOUS_REQUEST_FAILED: "T402-3012";
+declare const ERR_REQUEST_IN_PROGRESS: "T402-3013";
+declare const ERR_CHAIN_UNAVAILABLE: "T402-4001";
+declare const ERR_TRANSACTION_FAILED: "T402-4002";
+declare const ERR_TRANSACTION_REVERTED: "T402-4003";
+declare const ERR_GAS_ESTIMATION_FAILED: "T402-4004";
+declare const ERR_NONCE_CONFLICT: "T402-4005";
+declare const ERR_CHAIN_CONGESTED: "T402-4006";
+declare const ERR_CONTRACT_ERROR: "T402-4007";
+declare const ERR_BRIDGE_UNAVAILABLE: "T402-5001";
+declare const ERR_BRIDGE_QUOTE_FAILED: "T402-5002";
+declare const ERR_BRIDGE_TRANSFER_FAILED: "T402-5003";
+declare const ERR_BRIDGE_TIMEOUT: "T402-5004";
+declare const ERR_UNSUPPORTED_ROUTE: "T402-5005";
+declare const ERR_STREAM_NOT_FOUND: "T402-6001";
+declare const ERR_STREAM_ALREADY_CLOSED: "T402-6002";
+declare const ERR_STREAM_ALREADY_PAUSED: "T402-6003";
+declare const ERR_STREAM_NOT_PAUSED: "T402-6004";
+declare const ERR_STREAM_AMOUNT_EXCEEDED: "T402-6005";
+declare const ERR_STREAM_EXPIRED: "T402-6006";
+declare const ERR_STREAM_INVALID_STATE: "T402-6007";
+declare const ERR_STREAM_RATE_LIMITED: "T402-6008";
+declare const ERR_INTENT_NOT_FOUND: "T402-7001";
+declare const ERR_INTENT_ALREADY_EXECUTED: "T402-7002";
+declare const ERR_INTENT_CANCELLED: "T402-7003";
+declare const ERR_INTENT_EXPIRED: "T402-7004";
+declare const ERR_NO_ROUTES_AVAILABLE: "T402-7005";
+declare const ERR_ROUTE_EXPIRED: "T402-7006";
+declare const ERR_ROUTE_NOT_SELECTED: "T402-7007";
+declare const ERR_INTENT_INVALID_STATE: "T402-7008";
+declare const ERR_RESOURCE_NOT_FOUND: "T402-8001";
+declare const ERR_RESOURCE_ALREADY_EXISTS: "T402-8002";
+declare const ERR_INVALID_PARAMETERS: "T402-8003";
+declare const ERR_NOT_AUTHORIZED: "T402-8004";
+/** Union type of all T402 error codes */
+type ErrorCode = typeof ERR_INVALID_REQUEST | typeof ERR_MISSING_PAYLOAD | typeof ERR_MISSING_REQUIREMENTS | typeof ERR_INVALID_PAYLOAD | typeof ERR_INVALID_REQUIREMENTS | typeof ERR_INVALID_SIGNATURE | typeof ERR_INVALID_NETWORK | typeof ERR_INVALID_SCHEME | typeof ERR_INVALID_AMOUNT | typeof ERR_INVALID_ADDRESS | typeof ERR_EXPIRED_PAYMENT | typeof ERR_INVALID_NONCE | typeof ERR_INSUFFICIENT_AMOUNT | typeof ERR_INVALID_IDEMPOTENCY_KEY | typeof ERR_SIGNATURE_EXPIRED | typeof ERR_INTERNAL | typeof ERR_DATABASE_UNAVAILABLE | typeof ERR_CACHE_UNAVAILABLE | typeof ERR_RPC_UNAVAILABLE | typeof ERR_RATE_LIMITED | typeof ERR_SERVICE_UNAVAILABLE | typeof ERR_VERIFICATION_FAILED | typeof ERR_SETTLEMENT_FAILED | typeof ERR_INSUFFICIENT_BALANCE | typeof ERR_ALLOWANCE_INSUFFICIENT | typeof ERR_PAYMENT_MISMATCH | typeof ERR_DUPLICATE_PAYMENT | typeof ERR_SETTLEMENT_PENDING | typeof ERR_SETTLEMENT_TIMEOUT | typeof ERR_NONCE_REPLAY | typeof ERR_IDEMPOTENCY_CONFLICT | typeof ERR_IDEMPOTENCY_UNAVAILABLE | typeof ERR_PREVIOUS_REQUEST_FAILED | typeof ERR_REQUEST_IN_PROGRESS | typeof ERR_CHAIN_UNAVAILABLE | typeof ERR_TRANSACTION_FAILED | typeof ERR_TRANSACTION_REVERTED | typeof ERR_GAS_ESTIMATION_FAILED | typeof ERR_NONCE_CONFLICT | typeof ERR_CHAIN_CONGESTED | typeof ERR_CONTRACT_ERROR | typeof ERR_BRIDGE_UNAVAILABLE | typeof ERR_BRIDGE_QUOTE_FAILED | typeof ERR_BRIDGE_TRANSFER_FAILED | typeof ERR_BRIDGE_TIMEOUT | typeof ERR_UNSUPPORTED_ROUTE | typeof ERR_STREAM_NOT_FOUND | typeof ERR_STREAM_ALREADY_CLOSED | typeof ERR_STREAM_ALREADY_PAUSED | typeof ERR_STREAM_NOT_PAUSED | typeof ERR_STREAM_AMOUNT_EXCEEDED | typeof ERR_STREAM_EXPIRED | typeof ERR_STREAM_INVALID_STATE | typeof ERR_STREAM_RATE_LIMITED | typeof ERR_INTENT_NOT_FOUND | typeof ERR_INTENT_ALREADY_EXECUTED | typeof ERR_INTENT_CANCELLED | typeof ERR_INTENT_EXPIRED | typeof ERR_NO_ROUTES_AVAILABLE | typeof ERR_ROUTE_EXPIRED | typeof ERR_ROUTE_NOT_SELECTED | typeof ERR_INTENT_INVALID_STATE | typeof ERR_RESOURCE_NOT_FOUND | typeof ERR_RESOURCE_ALREADY_EXISTS | typeof ERR_INVALID_PARAMETERS | typeof ERR_NOT_AUTHORIZED;
+/** Structured error response from the facilitator API */
+interface APIError {
+    code: ErrorCode;
+    message: string;
+    details?: string;
+    retry?: boolean;
+}
+/** Returns the HTTP status code for a given error code */
+declare function httpStatusForCode(code: ErrorCode): number;
+/** Returns true if the error code is a client error (T402-1xxx) */
+declare function isClientError(code: ErrorCode): boolean;
+/** Returns true if the error code is a server error (T402-2xxx) */
+declare function isServerError(code: ErrorCode): boolean;
+/** Returns true if the error code is a facilitator error (T402-3xxx) */
+declare function isFacilitatorError(code: ErrorCode): boolean;
+/** Returns true if the error code is a chain error (T402-4xxx) */
+declare function isChainError(code: ErrorCode): boolean;
+/** Returns true if the error code is a bridge error (T402-5xxx) */
+declare function isBridgeError(code: ErrorCode): boolean;
+
+/**
+ * Zod schemas for T402 protocol types.
+ * Used for runtime validation of incoming data.
+ */
+declare const NetworkSchema: z.ZodString;
+declare const ResourceInfoSchema: z.ZodObject<{
+    url: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    url: string;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+}>;
+declare const PaymentRequirementsSchema: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodNumber;
+    extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}>;
+declare const PaymentRequiredSchema: z.ZodObject<{
+    t402Version: z.ZodLiteral<2>;
+    error: z.ZodOptional<z.ZodString>;
+    resource: z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }>;
+    accepts: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }>, "many">;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    t402Version: 2;
+    resource: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    };
+    accepts: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }[];
+    error?: string | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}, {
+    t402Version: 2;
+    resource: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    };
+    accepts: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }[];
+    error?: string | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>;
+declare const PaymentPayloadSchema: z.ZodObject<{
+    t402Version: z.ZodLiteral<2>;
+    resource: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    t402Version: 2;
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    };
+    payload: Record<string, unknown>;
+    resource?: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}, {
+    t402Version: 2;
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    };
+    payload: Record<string, unknown>;
+    resource?: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>;
+declare const VerifyResponseSchema: z.ZodObject<{
+    isValid: z.ZodBoolean;
+    invalidReason: z.ZodOptional<z.ZodString>;
+    payer: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    isValid: boolean;
+    invalidReason?: string | undefined;
+    payer?: string | undefined;
+}, {
+    isValid: boolean;
+    invalidReason?: string | undefined;
+    payer?: string | undefined;
+}>;
+declare const SettleResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    transaction: z.ZodString;
+    network: z.ZodString;
+    errorReason: z.ZodOptional<z.ZodString>;
+    payer: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    network: string;
+    success: boolean;
+    transaction: string;
+    payer?: string | undefined;
+    errorReason?: string | undefined;
+}, {
+    network: string;
+    success: boolean;
+    transaction: string;
+    payer?: string | undefined;
+    errorReason?: string | undefined;
+}>;
+declare const PaymentRequirementsV1Schema: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodNumber;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown> | undefined;
+}, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown> | undefined;
+}>;
+declare const PaymentPayloadV1Schema: z.ZodObject<{
+    t402Version: z.ZodOptional<z.ZodLiteral<1>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    };
+    payload: Record<string, unknown>;
+    t402Version?: 1 | undefined;
+}, {
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    };
+    payload: Record<string, unknown>;
+    t402Version?: 1 | undefined;
+}>;
+type ValidatedPaymentPayload = z.infer<typeof PaymentPayloadSchema>;
+type ValidatedPaymentRequired = z.infer<typeof PaymentRequiredSchema>;
+type ValidatedPaymentRequirements = z.infer<typeof PaymentRequirementsSchema>;
+type ValidatedVerifyResponse = z.infer<typeof VerifyResponseSchema>;
+type ValidatedSettleResponse = z.infer<typeof SettleResponseSchema>;
+/**
+ * Parse and validate a PaymentPayload.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment payload
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentPayload(data: unknown): ValidatedPaymentPayload;
+/**
+ * Parse and validate a PaymentRequired response.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment required response
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentRequired(data: unknown): ValidatedPaymentRequired;
+/**
+ * Parse and validate PaymentRequirements.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment requirements
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentRequirements(data: unknown): ValidatedPaymentRequirements;
+/**
+ * Safely parse a PaymentPayload, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentPayload(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentPayload>;
+/**
+ * Safely parse a PaymentRequired response, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentRequired(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentRequired>;
+/**
+ * Safely parse PaymentRequirements, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentRequirements(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentRequirements>;
+
+type Network = `${string}:${string}`;
+type Money = string | number;
+type AssetAmount = {
+    asset: string;
+    amount: string;
+    extra?: Record<string, unknown>;
+};
+type Price = Money | AssetAmount;
+
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+type PaymentRequirements = {
+    scheme: string;
+    network: Network;
+    asset: string;
+    amount: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+};
+type PaymentRequired = {
+    t402Version: number;
+    error?: string;
+    resource: ResourceInfo;
+    accepts: PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+};
+type PaymentPayload = {
+    t402Version: number;
+    resource?: ResourceInfo;
+    accepted: PaymentRequirements;
+    payload: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+};
+
+type VerifyRequest = {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+};
+type VerifyResponse = {
+    isValid: boolean;
+    invalidReason?: string;
+    payer?: string;
+};
+type SettleRequest = {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+};
+type SettleResponse = {
+    success: boolean;
+    errorReason?: string;
+    payer?: string;
+    transaction: string;
+    network: Network;
+};
+type SupportedKind = {
+    t402Version: number;
+    scheme: string;
+    network: Network;
+    extra?: Record<string, unknown>;
+};
+type SupportedResponse = {
+    kinds: SupportedKind[];
+    extensions: string[];
+    signers: Record<string, string[]>;
+};
+
+/**
+ * Money parser function that converts a numeric amount to an AssetAmount
+ * Receives the amount as a decimal number (e.g., 1.50 for $1.50)
+ * Returns null to indicate "cannot handle this amount", causing fallback to next parser
+ * Always returns a Promise for consistency - use async/await
+ *
+ * @param amount - The decimal amount (e.g., 1.50)
+ * @param network - The network identifier for context
+ * @returns AssetAmount or null to try next parser
+ */
+type MoneyParser = (amount: number, network: Network) => Promise<AssetAmount | null>;
+interface SchemeNetworkClient {
+    readonly scheme: string;
+    createPaymentPayload(t402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "t402Version" | "payload">>;
+}
+interface SchemeNetworkFacilitator {
+    readonly scheme: string;
+    /**
+     * CAIP family pattern that this facilitator supports.
+     * Used to group signers by blockchain family in the supported response.
+     *
+     * @example
+     * // EVM facilitators
+     * readonly caipFamily = "eip155:*";
+     *
+     * @example
+     * // SVM facilitators
+     * readonly caipFamily = "solana:*";
+     */
+    readonly caipFamily: string;
+    /**
+     * Get mechanism-specific extra data needed for the supported kinds endpoint.
+     * This method is called when building the facilitator's supported response.
+     *
+     * @param network - The network identifier for context
+     * @returns Extra data object or undefined if no extra data is needed
+     *
+     * @example
+     * // EVM schemes return undefined (no extra data needed)
+     * getExtra(network: Network): undefined {
+     *   return undefined;
+     * }
+     *
+     * @example
+     * // SVM schemes return feePayer address
+     * getExtra(network: Network): Record<string, unknown> | undefined {
+     *   return { feePayer: this.signer.address };
+     * }
+     */
+    getExtra(network: Network): Record<string, unknown> | undefined;
+    /**
+     * Get signer addresses used by this facilitator for a given network.
+     * These are included in the supported response to help clients understand
+     * which addresses might sign/pay for transactions.
+     *
+     * Supports multiple addresses for load balancing, key rotation, and high availability.
+     *
+     * @param network - The network identifier
+     * @returns Array of signer addresses (wallet addresses, fee payer addresses, etc.)
+     *
+     * @example
+     * // EVM facilitator
+     * getSigners(network: string): string[] {
+     *   return [...this.signer.getAddresses()];
+     * }
+     *
+     * @example
+     * // SVM facilitator
+     * getSigners(network: string): string[] {
+     *   return [...this.signer.getAddresses()];
+     * }
+     */
+    getSigners(network: string): string[];
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+}
+interface SchemeNetworkServer {
+    readonly scheme: string;
+    /**
+     * Convert a user-friendly price to the scheme's specific amount and asset format
+     * Always returns a Promise for consistency
+     *
+     * @param price - User-friendly price (e.g., "$0.10", "0.10", { amount: "100000", asset: "USDC" })
+     * @param network - The network identifier for context
+     * @returns Promise that resolves to the converted amount, asset identifier, and any extra metadata
+     *
+     * @example
+     * // For EVM networks with USDC:
+     * await parsePrice("$0.10", "eip155:8453") => { amount: "100000", asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }
+     *
+     * // For custom schemes:
+     * await parsePrice("10 points", "custom:network") => { amount: "10", asset: "points" }
+     */
+    parsePrice(price: Price, network: Network): Promise<AssetAmount>;
+    /**
+     * Build payment requirements for this scheme/network combination
+     *
+     * @param paymentRequirements - Base payment requirements with amount/asset already set
+     * @param supportedKind - The supported kind from facilitator's /supported endpoint
+     * @param supportedKind.t402Version - The t402 version
+     * @param supportedKind.scheme - The payment scheme
+     * @param supportedKind.network - The network identifier
+     * @param supportedKind.extra - Optional extra metadata
+     * @param facilitatorExtensions - Extensions supported by the facilitator
+     * @returns Enhanced payment requirements ready to be sent to clients
+     */
+    enhancePaymentRequirements(paymentRequirements: PaymentRequirements, supportedKind: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }, facilitatorExtensions: string[]): Promise<PaymentRequirements>;
+}
+
+export { createPaymentFailedMessage as $, type AssetAmount as A, type A2AArtifact as B, type A2ATaskStatus as C, type A2ATask as D, type A2ARequest as E, type A2AResponse as F, type A2AError as G, type A2AExtension as H, type A2ACapabilities as I, type A2AAgentCard as J, type A2ASkill as K, A2A_EXTENSIONS_HEADER as L, type Money as M, type Network as N, isPaymentRequired as O, type PaymentRequirements as P, isPaymentCompleted as Q, type ResourceServerExtension as R, type SettleResponse as S, T402_A2A_EXTENSION_URI as T, isPaymentFailed as U, type VerifyResponse as V, getPaymentRequired as W, getPaymentReceipts as X, createPaymentRequiredMessage as Y, createPaymentSubmissionMessage as Z, createPaymentCompletedMessage as _, type PaymentPayload as a, ERR_STREAM_NOT_FOUND as a$, createT402Extension as a0, type UptoPaymentRequirements as a1, type UptoExtra as a2, type UptoPayloadBase as a3, type UptoEvmPayload as a4, type UptoEvmPayloadCompact as a5, type UptoSettlement as a6, type UptoUsageDetails as a7, type UptoSettlementResponse as a8, type UptoValidationResult as a9, ERR_RATE_LIMITED as aA, ERR_SERVICE_UNAVAILABLE as aB, ERR_VERIFICATION_FAILED as aC, ERR_SETTLEMENT_FAILED as aD, ERR_INSUFFICIENT_BALANCE as aE, ERR_ALLOWANCE_INSUFFICIENT as aF, ERR_PAYMENT_MISMATCH as aG, ERR_DUPLICATE_PAYMENT as aH, ERR_SETTLEMENT_PENDING as aI, ERR_SETTLEMENT_TIMEOUT as aJ, ERR_NONCE_REPLAY as aK, ERR_IDEMPOTENCY_CONFLICT as aL, ERR_IDEMPOTENCY_UNAVAILABLE as aM, ERR_PREVIOUS_REQUEST_FAILED as aN, ERR_REQUEST_IN_PROGRESS as aO, ERR_CHAIN_UNAVAILABLE as aP, ERR_TRANSACTION_FAILED as aQ, ERR_TRANSACTION_REVERTED as aR, ERR_GAS_ESTIMATION_FAILED as aS, ERR_NONCE_CONFLICT as aT, ERR_CHAIN_CONGESTED as aU, ERR_CONTRACT_ERROR as aV, ERR_BRIDGE_UNAVAILABLE as aW, ERR_BRIDGE_QUOTE_FAILED as aX, ERR_BRIDGE_TRANSFER_FAILED as aY, ERR_BRIDGE_TIMEOUT as aZ, ERR_UNSUPPORTED_ROUTE as a_, type UptoUnit as aa, isUptoPaymentRequirements as ab, isUptoEvmPayload as ac, UPTO_SCHEME as ad, UPTO_DEFAULTS as ae, type ErrorCode as af, type APIError as ag, ERR_INVALID_REQUEST as ah, ERR_MISSING_PAYLOAD as ai, ERR_MISSING_REQUIREMENTS as aj, ERR_INVALID_PAYLOAD as ak, ERR_INVALID_REQUIREMENTS as al, ERR_INVALID_SIGNATURE as am, ERR_INVALID_NETWORK as an, ERR_INVALID_SCHEME as ao, ERR_INVALID_AMOUNT as ap, ERR_INVALID_ADDRESS as aq, ERR_EXPIRED_PAYMENT as ar, ERR_INVALID_NONCE as as, ERR_INSUFFICIENT_AMOUNT as at, ERR_INVALID_IDEMPOTENCY_KEY as au, ERR_SIGNATURE_EXPIRED as av, ERR_INTERNAL as aw, ERR_DATABASE_UNAVAILABLE as ax, ERR_CACHE_UNAVAILABLE as ay, ERR_RPC_UNAVAILABLE as az, type SchemeNetworkFacilitator as b, ERR_STREAM_ALREADY_CLOSED as b0, ERR_STREAM_ALREADY_PAUSED as b1, ERR_STREAM_NOT_PAUSED as b2, ERR_STREAM_AMOUNT_EXCEEDED as b3, ERR_STREAM_EXPIRED as b4, ERR_STREAM_INVALID_STATE as b5, ERR_STREAM_RATE_LIMITED as b6, ERR_INTENT_NOT_FOUND as b7, ERR_INTENT_ALREADY_EXECUTED as b8, ERR_INTENT_CANCELLED as b9, parsePaymentRequirements as bA, safeParsePaymentPayload as bB, safeParsePaymentRequired as bC, safeParsePaymentRequirements as bD, type ValidatedPaymentPayload as bE, type ValidatedPaymentRequired as bF, type ValidatedPaymentRequirements as bG, type ValidatedVerifyResponse as bH, type ValidatedSettleResponse as bI, ERR_INTENT_EXPIRED as ba, ERR_NO_ROUTES_AVAILABLE as bb, ERR_ROUTE_EXPIRED as bc, ERR_ROUTE_NOT_SELECTED as bd, ERR_INTENT_INVALID_STATE as be, ERR_RESOURCE_NOT_FOUND as bf, ERR_RESOURCE_ALREADY_EXISTS as bg, ERR_INVALID_PARAMETERS as bh, ERR_NOT_AUTHORIZED as bi, httpStatusForCode as bj, isClientError as bk, isServerError as bl, isFacilitatorError as bm, isChainError as bn, isBridgeError as bo, NetworkSchema as bp, ResourceInfoSchema as bq, PaymentRequirementsSchema as br, PaymentRequiredSchema as bs, PaymentPayloadSchema as bt, VerifyResponseSchema as bu, SettleResponseSchema as bv, PaymentRequirementsV1Schema as bw, PaymentPayloadV1Schema as bx, parsePaymentPayload as by, parsePaymentRequired as bz, type PaymentRequired as c, type SchemeNetworkClient as d, type SupportedResponse as e, type SchemeNetworkServer as f, type SupportedKind as g, type Price as h, type PaymentRequirementsV1 as i, type PaymentRequiredV1 as j, type PaymentPayloadV1 as k, type VerifyRequestV1 as l, type SettleRequestV1 as m, type SettleResponseV1 as n, type SupportedResponseV1 as o, type VerifyRequest as p, type SettleRequest as q, type MoneyParser as r, type A2APaymentStatus as s, type A2ATaskState as t, type A2ATextPart as u, type A2AFilePart as v, type A2ADataPart as w, type A2AMessagePart as x, type A2APaymentMetadata as y, type A2AMessage as z };