@atxp/client 0.10.6 → 0.10.8

package/dist/index.js

@@ -1,7 +1,8 @@
-import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, getErrorRecoveryHint, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, createReactNativeSafeFetch, getIsReactNative, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, ATXPAccount } from '@atxp/common';
+import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, getErrorRecoveryHint, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, createReactNativeSafeFetch, getIsReactNative, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, ATXPAccount, AuthorizationError } from '@atxp/common';
 export { ATXPAccount } from '@atxp/common';
 import * as oauth from 'oauth4webapi';
 import { BigNumber } from 'bignumber.js';
+import { hasMPPChallenge, hasMPPMCPError, parseMPPHeader, MPP_ERROR_CODE, parseMPPFromMCPError } from '@atxp/mpp';
 
 class OAuthAuthenticationRequiredError extends Error {
     constructor(url, resourceServerUrl, 
@@ -453,7 +454,9 @@ function atxpFetch(config) {
         onAuthorizeFailure: config.onAuthorizeFailure,
         onPayment: config.onPayment,
         onPaymentFailure: config.onPaymentFailure,
-        onPaymentAttemptFailed: config.onPaymentAttemptFailed
+        onPaymentAttemptFailed: config.onPaymentAttemptFailed,
+        protocolHandlers: config.protocolHandlers,
+        protocolFlag: config.protocolFlag
     });
     return fetcher.fetch;
 }
@@ -842,6 +845,11 @@ class ATXPFetcher {
             try {
                 // Try to fetch the resource
                 response = await oauthClient.fetch(url, init);
+                // Check HTTP-level protocol handlers first (e.g., X402 402 responses)
+                const handlerResult = await this.tryProtocolHandlers(response, url, init);
+                if (handlerResult) {
+                    return handlerResult;
+                }
                 await this.checkForATXPResponse(response);
                 return response;
             }
@@ -854,6 +862,11 @@ class ATXPFetcher {
                     try {
                         // Retry the request once - we should be auth'd now
                         response = await oauthClient.fetch(url, init);
+                        // Check protocol handlers again after auth
+                        const handlerResult = await this.tryProtocolHandlers(response, url, init);
+                        if (handlerResult) {
+                            return handlerResult;
+                        }
                         await this.checkForATXPResponse(response);
                         return response;
                     }
@@ -886,7 +899,7 @@ class ATXPFetcher {
                 throw error;
             }
         };
-        const { account, db, destinationMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure, onPaymentAttemptFailed } = config;
+        const { account, db, destinationMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure, onPaymentAttemptFailed, protocolHandlers = [], protocolFlag } = config;
         // Use React Native safe fetch if in React Native environment
         this.safeFetchFn = getIsReactNative() ? createReactNativeSafeFetch(fetchFn) : fetchFn;
         const safeSideChannelFetch = getIsReactNative() ? createReactNativeSafeFetch(sideChannelFetch) : sideChannelFetch;
@@ -905,6 +918,8 @@ class ATXPFetcher {
         this.onPayment = onPayment;
         this.onPaymentFailure = onPaymentFailure || this.defaultPaymentFailureHandler;
         this.onPaymentAttemptFailed = onPaymentAttemptFailed;
+        this.protocolHandlers = protocolHandlers;
+        this.protocolFlag = protocolFlag;
     }
     /**
      * Get or create the OAuthClient (lazy initialization to support async accountId)
@@ -927,6 +942,55 @@ class ATXPFetcher {
         });
         return this.oauthClient;
     }
+    /**
+     * Build protocol config for passing to protocol handlers.
+     */
+    getProtocolConfig() {
+        return {
+            account: this.account,
+            logger: this.logger,
+            fetchFn: this.safeFetchFn,
+            approvePayment: this.approvePayment,
+            onPayment: this.onPayment,
+            onPaymentFailure: this.onPaymentFailure
+        };
+    }
+    /**
+     * Try to handle an HTTP-level payment challenge using registered protocol handlers.
+     * For omni-challenges, uses protocolFlag to select the preferred handler.
+     * For single-protocol challenges, auto-detects from response format.
+     *
+     * @returns The retry response from the selected handler, or null if no handler matched
+     */
+    async tryProtocolHandlers(response, url, init) {
+        if (this.protocolHandlers.length === 0)
+            return null;
+        // Find all handlers that can handle this response
+        const matchingHandlers = [];
+        for (const handler of this.protocolHandlers) {
+            if (await handler.canHandle(response.clone())) {
+                matchingHandlers.push(handler);
+            }
+        }
+        if (matchingHandlers.length === 0)
+            return null;
+        // Select handler: use protocolFlag for omni-challenges, otherwise use first match
+        let selectedHandler;
+        if (matchingHandlers.length > 1 && this.protocolFlag) {
+            const accountId = await this.account.getAccountId();
+            const destination = typeof url === 'string' ? url : url.toString();
+            const preferredProtocol = this.protocolFlag(accountId, destination);
+            const preferred = matchingHandlers.find(h => h.protocol === preferredProtocol);
+            selectedHandler = preferred ?? matchingHandlers[0];
+            this.logger.info(`Protocol flag selected '${preferredProtocol}', using handler '${selectedHandler.protocol}'`);
+        }
+        else {
+            selectedHandler = matchingHandlers[0];
+            this.logger.debug(`Auto-detected protocol handler: ${selectedHandler.protocol}`);
+        }
+        const config = this.getProtocolConfig();
+        return selectedHandler.handlePaymentChallenge(response, { url, init }, config);
+    }
 }
 
 /** A special constant with type `never` */
@@ -24522,6 +24586,12 @@ function createDestinationMakers(config) {
             case NetworkEnum.PolygonAmoy:
                 makers.set(network, new PassthroughDestinationMaker(network));
                 break;
+            case NetworkEnum.Tempo:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.TempoModerato:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
             case NetworkEnum.ATXP:
                 makers.set(network, new ATXPDestinationMaker(atxpAccountsServer, fetchFn));
                 break;
@@ -24868,5 +24938,486 @@ class ATXPLocalAccount {
     }
 }
 
-export { ATXPDestinationMaker, ATXPLocalAccount, ATXPPaymentError, DEFAULT_CLIENT_CONFIG, GasEstimationError, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentExpiredError, PaymentNetworkError, PaymentServerError, RpcError, TransactionRevertedError, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, UnsupportedCurrencyError, UserRejectedError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
+/**
+ * Build protocol-specific payment headers for retrying a request after authorization.
+ *
+ * @param result - The authorization result containing protocol and credential
+ * @param originalHeaders - Optional original request headers to preserve
+ * @returns New Headers object with protocol-specific payment headers added
+ */
+function buildPaymentHeaders(result, originalHeaders) {
+    let headers;
+    if (originalHeaders instanceof Headers) {
+        headers = new Headers(originalHeaders);
+    }
+    else if (originalHeaders) {
+        headers = new Headers(originalHeaders);
+    }
+    else {
+        headers = new Headers();
+    }
+    switch (result.protocol) {
+        case 'x402':
+            headers.set('X-PAYMENT', result.credential);
+            headers.set('Access-Control-Expose-Headers', 'X-PAYMENT-RESPONSE');
+            break;
+        case 'mpp':
+            headers.set('Authorization', `Payment ${result.credential}`);
+            break;
+    }
+    return headers;
+}
+/**
+ * Client for authorizing payments.
+ *
+ * Resolves the payment protocol via protocolFlag, then delegates to
+ * account.authorize() for the actual authorization logic.
+ */
+class PaymentClient {
+    constructor(config) {
+        this.protocolFlag = config.protocolFlag;
+        this.logger = config.logger;
+    }
+    /**
+     * Authorize a payment by delegating to the account's authorize method.
+     *
+     * PaymentClient resolves the protocol (via explicit param or protocolFlag),
+     * then delegates all protocol-specific logic to account.authorize().
+     *
+     * @param params.account - The account to authorize the payment through
+     * @param params.userId - Passed to protocolFlag for protocol selection
+     * @param params.destination - Payment destination address
+     * @param params.protocol - Explicit protocol override (skips protocolFlag)
+     * @param params.amount - Payment amount
+     * @param params.memo - Payment memo
+     * @param params.paymentRequirements - X402 payment requirements
+     * @param params.challenge - MPP challenge object
+     * @returns AuthorizeResult with protocol and opaque credential
+     */
+    async authorize(params) {
+        const { account, userId, destination } = params;
+        // Determine protocol
+        const protocol = params.protocol
+            ?? (this.protocolFlag ? this.protocolFlag(userId, destination) : 'atxp');
+        // Delegate to the account's authorize method
+        return account.authorize({
+            protocol,
+            amount: params.amount,
+            destination,
+            memo: params.memo,
+            paymentRequirements: params.paymentRequirements,
+            challenge: params.challenge,
+        });
+    }
+}
+
+function isX402Challenge(obj) {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const candidate = obj;
+    return (typeof candidate.x402Version !== 'undefined' &&
+        Array.isArray(candidate.accepts));
+}
+/**
+ * Protocol handler for X402 payment challenges.
+ *
+ * Detects HTTP 402 responses with x402Version in the JSON body.
+ * Creates payment headers using the x402 library and retries the request.
+ */
+class X402ProtocolHandler {
+    constructor(config) {
+        this.protocol = 'x402';
+        this.accountsServer = config?.accountsServer ?? 'https://accounts.atxp.ai';
+    }
+    async canHandle(response) {
+        if (response.status !== 402)
+            return false;
+        try {
+            const cloned = response.clone();
+            const body = await cloned.text();
+            const parsed = JSON.parse(body);
+            return isX402Challenge(parsed);
+        }
+        catch {
+            return false;
+        }
+    }
+    async handlePaymentChallenge(response, originalRequest, config) {
+        const { account, logger, fetchFn, approvePayment, onPayment, onPaymentFailure } = config;
+        const responseBody = await response.text();
+        let paymentChallenge;
+        try {
+            paymentChallenge = JSON.parse(responseBody);
+        }
+        catch {
+            logger.error('X402: failed to parse challenge body');
+            return null;
+        }
+        if (!isX402Challenge(paymentChallenge)) {
+            return null;
+        }
+        try {
+            const { selectPaymentRequirements } = await import('x402/client');
+            const selectedPaymentRequirements = selectPaymentRequirements(paymentChallenge.accepts, undefined, 'exact');
+            if (!selectedPaymentRequirements) {
+                logger.info('X402: no suitable payment option found');
+                return this.reconstructResponse(responseBody, response);
+            }
+            const amountInUsdc = Number(selectedPaymentRequirements.maxAmountRequired) / (10 ** 6);
+            const network = selectedPaymentRequirements.network;
+            logger.debug(`X402: payment required: ${amountInUsdc} USDC on ${network} to ${selectedPaymentRequirements.payTo}`);
+            const url = typeof originalRequest.url === 'string' ? originalRequest.url : originalRequest.url.toString();
+            const accountId = await account.getAccountId();
+            const prospectivePayment = {
+                accountId,
+                resourceUrl: url,
+                resourceName: selectedPaymentRequirements.description || url,
+                currency: 'USDC',
+                amount: new BigNumber(amountInUsdc),
+                iss: selectedPaymentRequirements.payTo
+            };
+            const approved = await approvePayment(prospectivePayment);
+            if (!approved) {
+                logger.info('X402: payment not approved');
+                const error = new Error('Payment not approved');
+                await onPaymentFailure({
+                    payment: prospectivePayment,
+                    error,
+                    attemptedNetworks: [network],
+                    failureReasons: new Map([[network, error]]),
+                    retryable: true,
+                    timestamp: new Date()
+                });
+                return this.reconstructResponse(responseBody, response);
+            }
+            // Authorize via account.authorize() — ATXPAccount calls the accounts
+            // service, BaseAccount signs locally. No fallback — each account type
+            // handles authorization according to its capabilities.
+            const client = new PaymentClient({
+                accountsServer: this.accountsServer,
+                logger,
+                fetchFn,
+            });
+            const authorizeResult = await client.authorize({
+                account,
+                userId: accountId,
+                destination: url,
+                protocol: 'x402',
+                paymentRequirements: selectedPaymentRequirements,
+            });
+            const paymentHeader = authorizeResult.credential;
+            // Retry with X-PAYMENT header
+            const retryHeaders = buildPaymentHeaders({ protocol: 'x402', credential: paymentHeader }, originalRequest.init?.headers);
+            const retryInit = { ...originalRequest.init, headers: retryHeaders };
+            logger.info('X402: retrying request with X-PAYMENT header');
+            const retryResponse = await fetchFn(originalRequest.url, retryInit);
+            if (retryResponse.ok) {
+                logger.info('X402: payment accepted');
+                await onPayment({
+                    payment: prospectivePayment,
+                    transactionHash: paymentHeader.substring(0, 66),
+                    network
+                });
+            }
+            else {
+                logger.warn(`X402: request failed after payment with status ${retryResponse.status}`);
+                const error = new Error(`Request failed with status ${retryResponse.status}`);
+                await onPaymentFailure({
+                    payment: prospectivePayment,
+                    error,
+                    attemptedNetworks: [network],
+                    failureReasons: new Map([[network, error]]),
+                    retryable: false,
+                    timestamp: new Date()
+                });
+            }
+            return retryResponse;
+        }
+        catch (error) {
+            logger.error(`X402: failed to handle payment challenge: ${error}`);
+            if (isX402Challenge(paymentChallenge) && paymentChallenge.accepts[0]) {
+                const firstOption = paymentChallenge.accepts[0];
+                const amount = firstOption.maxAmountRequired ? Number(firstOption.maxAmountRequired) / (10 ** 6) : 0;
+                const url = typeof originalRequest.url === 'string' ? originalRequest.url : originalRequest.url.toString();
+                const accountId = await account.getAccountId();
+                const errorNetwork = firstOption.network || 'unknown';
+                const typedError = error;
+                const isRetryable = typedError instanceof ATXPPaymentError ? typedError.retryable : true;
+                await onPaymentFailure({
+                    payment: {
+                        accountId,
+                        resourceUrl: url,
+                        resourceName: firstOption.description || url,
+                        currency: 'USDC',
+                        amount: new BigNumber(amount),
+                        iss: firstOption.payTo || ''
+                    },
+                    error: typedError,
+                    attemptedNetworks: [errorNetwork],
+                    failureReasons: new Map([[errorNetwork, typedError]]),
+                    retryable: isRetryable,
+                    timestamp: new Date()
+                });
+            }
+            return this.reconstructResponse(responseBody, response);
+        }
+    }
+    reconstructResponse(body, original) {
+        return new Response(body, {
+            status: original.status,
+            statusText: original.statusText,
+            headers: original.headers
+        });
+    }
+}
+
+/**
+ * Protocol handler for ATXP-MCP payment challenges.
+ *
+ * Detects JSON-RPC errors with code -30402 (PAYMENT_REQUIRED_ERROR_CODE) in
+ * MCP responses (both SSE and JSON formats).
+ */
+class ATXPProtocolHandler {
+    constructor() {
+        this.protocol = 'atxp';
+    }
+    async canHandle(response) {
+        // ATXP-MCP challenges are embedded in MCP JSON-RPC responses,
+        // not at the HTTP level. We detect them by looking for error code -30402.
+        try {
+            const cloned = response.clone();
+            const body = await cloned.text();
+            if (body.length === 0)
+                return false;
+            const paymentRequests = await this.extractPaymentRequests(body);
+            return paymentRequests.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async handlePaymentChallenge(response, _originalRequest, config) {
+        const { logger } = config;
+        try {
+            const body = await response.clone().text();
+            const paymentRequests = await this.extractPaymentRequests(body);
+            if (paymentRequests.length === 0) {
+                return null;
+            }
+            // ATXP-MCP payment challenges are handled through the fetcher's
+            // checkForATXPResponse → handlePaymentRequestError flow, not at
+            // the HTTP protocol handler level. Return null so the fetcher's
+            // existing MCP payment flow picks it up.
+            // This handler's role in the strategy pattern is detection via
+            // canHandle() for protocol selection (e.g., protocolFlag), not
+            // direct payment handling.
+            if (paymentRequests.length > 1) {
+                logger.warn(`ATXP: multiple payment requirements found in MCP response. ` +
+                    `The client does not support multiple payment requirements. ` +
+                    `${paymentRequests.map(pr => pr.url).join(', ')}`);
+            }
+            else {
+                logger.info(`ATXP: payment requirement found in MCP response - ${paymentRequests[0].url}`);
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error(`ATXP: error checking for payment requirements: ${error}`);
+            return null;
+        }
+    }
+    async extractPaymentRequests(body) {
+        try {
+            if (isSSEResponse(body)) {
+                const messages = await parseMcpMessages(body);
+                return messages.flatMap(message => parsePaymentRequests(message)).filter((pr) => pr !== null);
+            }
+            else {
+                const json = JSON.parse(body);
+                const messages = await parseMcpMessages(json);
+                return messages.flatMap(message => parsePaymentRequests(message)).filter((pr) => pr !== null);
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+}
+
+/**
+ * Protocol handler for MPP (Machine Payments Protocol) payment challenges.
+ *
+ * Detects MPP challenges in two forms:
+ * 1. HTTP level: HTTP 402 with WWW-Authenticate: Payment header
+ * 2. MCP level: JSON-RPC error with code -32042 containing MPP data
+ *
+ * Handles the challenge by calling /authorize/mpp on the accounts service
+ * and retrying with an Authorization: Payment header.
+ */
+class MPPProtocolHandler {
+    constructor(config) {
+        this.protocol = 'mpp';
+        this.accountsServer = config?.accountsServer ?? 'https://accounts.atxp.ai';
+    }
+    async canHandle(response) {
+        if (hasMPPChallenge(response))
+            return true;
+        return hasMPPMCPError(response);
+    }
+    async handlePaymentChallenge(response, originalRequest, config) {
+        const { account, logger, approvePayment } = config;
+        // Extract the challenge and body text from the response
+        const extracted = await this.extractChallenge(response, logger);
+        if (!extracted) {
+            logger.error('MPP: failed to extract challenge from response');
+            return null;
+        }
+        const { challenge, bodyText } = extracted;
+        const url = typeof originalRequest.url === 'string'
+            ? originalRequest.url
+            : originalRequest.url.toString();
+        // Build prospective payment for approval
+        const accountId = await account.getAccountId();
+        const prospectivePayment = this.buildProspectivePayment(challenge, url, accountId);
+        // Ask for approval
+        const approved = await approvePayment(prospectivePayment);
+        if (!approved) {
+            logger.info('MPP: payment not approved');
+            await this.reportFailure(config, prospectivePayment, new Error('Payment not approved'), challenge.network, true);
+            return this.reconstructResponse(bodyText, response);
+        }
+        return this.authorizeAndRetry(challenge, prospectivePayment, originalRequest, config, bodyText, response);
+    }
+    /**
+     * Extract MPP challenge from response - tries HTTP header first, then MCP error body.
+     * Returns both the challenge and the body text to avoid double-consumption.
+     */
+    async extractChallenge(response, logger) {
+        // Read body once upfront to avoid double consumption (response.text() can only be called once)
+        let bodyText = '';
+        try {
+            bodyText = await response.text();
+        }
+        catch {
+            // Body may not be available
+        }
+        // Try HTTP header first
+        const header = response.headers.get('WWW-Authenticate');
+        if (header) {
+            const challenge = parseMPPHeader(header);
+            if (challenge) {
+                logger.debug('MPP: parsed challenge from WWW-Authenticate header');
+                return { challenge, bodyText };
+            }
+        }
+        // Try MCP error body (use clone since response body may have been consumed above)
+        try {
+            const parsed = JSON.parse(bodyText);
+            if (typeof parsed === 'object' &&
+                parsed !== null &&
+                typeof parsed.error === 'object' &&
+                parsed.error !== null &&
+                parsed.error.code === MPP_ERROR_CODE) {
+                const challenge = parseMPPFromMCPError(parsed.error.data);
+                if (challenge) {
+                    logger.debug('MPP: parsed challenge from MCP error body');
+                    return { challenge, bodyText };
+                }
+            }
+        }
+        catch {
+            // Not JSON or malformed
+        }
+        return null;
+    }
+    /**
+     * Build a ProspectivePayment from an MPP challenge.
+     */
+    buildProspectivePayment(challenge, url, accountId) {
+        const amountNum = Number(challenge.amount) / (10 ** 6);
+        return {
+            accountId,
+            resourceUrl: url,
+            resourceName: url,
+            currency: challenge.currency,
+            amount: new BigNumber(amountNum),
+            iss: challenge.recipient,
+        };
+    }
+    /**
+     * Report a payment failure via the onPaymentFailure callback.
+     */
+    async reportFailure(config, payment, error, network, retryable) {
+        await config.onPaymentFailure({
+            payment,
+            error,
+            attemptedNetworks: [network],
+            failureReasons: new Map([[network, error]]),
+            retryable,
+            timestamp: new Date(),
+        });
+    }
+    /**
+     * Call /authorize/mpp on accounts service and retry the original request with the credential.
+     */
+    async authorizeAndRetry(challenge, prospectivePayment, originalRequest, config, bodyText, originalResponse) {
+        const { account, logger, fetchFn, onPayment } = config;
+        try {
+            logger.debug('MPP: calling /authorize/mpp on accounts service');
+            const client = new PaymentClient({
+                accountsServer: this.accountsServer,
+                logger,
+                fetchFn,
+            });
+            const accountId = await account.getAccountId();
+            let authorizeResult;
+            try {
+                authorizeResult = await client.authorize({
+                    account,
+                    userId: accountId,
+                    destination: typeof originalRequest.url === 'string' ? originalRequest.url : originalRequest.url.toString(),
+                    protocol: 'mpp',
+                    challenge,
+                });
+            }
+            catch (authorizeError) {
+                // AuthorizationError = server rejected the request (HTTP error from accounts)
+                // Other errors = data validation or network failure
+                if (authorizeError instanceof AuthorizationError) {
+                    logger.debug(`MPP: /authorize/mpp rejected (${authorizeError.statusCode}), returning original response`);
+                    return this.reconstructResponse(bodyText, originalResponse);
+                }
+                throw authorizeError;
+            }
+            const retryHeaders = buildPaymentHeaders(authorizeResult, originalRequest.init?.headers);
+            const retryInit = { ...originalRequest.init, headers: retryHeaders };
+            logger.info('MPP: retrying request with Authorization: Payment header');
+            const retryResponse = await fetchFn(originalRequest.url, retryInit);
+            if (retryResponse.ok) {
+                logger.info('MPP: payment accepted');
+                await onPayment({ payment: prospectivePayment, transactionHash: challenge.id, network: challenge.network });
+            }
+            else {
+                logger.warn(`MPP: request failed after payment with status ${retryResponse.status}`);
+                await this.reportFailure(config, prospectivePayment, new Error(`Request failed with status ${retryResponse.status}`), challenge.network, false);
+            }
+            return retryResponse;
+        }
+        catch (error) {
+            logger.error(`MPP: failed to handle payment challenge: ${error}`);
+            const cause = error instanceof Error ? error : new Error(String(error));
+            await this.reportFailure(config, prospectivePayment, cause, challenge.network, true);
+            return this.reconstructResponse(bodyText, originalResponse);
+        }
+    }
+    reconstructResponse(body, original) {
+        return new Response(body || null, {
+            status: original.status,
+            statusText: original.statusText,
+            headers: original.headers,
+        });
+    }
+}
+
+export { ATXPDestinationMaker, ATXPLocalAccount, ATXPPaymentError, ATXPProtocolHandler, DEFAULT_CLIENT_CONFIG, GasEstimationError, InsufficientFundsError, MPPProtocolHandler, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentClient, PaymentExpiredError, PaymentNetworkError, PaymentServerError, RpcError, TransactionRevertedError, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, UnsupportedCurrencyError, UserRejectedError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, X402ProtocolHandler, atxpClient, atxpFetch, buildClientConfig, buildPaymentHeaders, buildStreamableTransport, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
 //# sourceMappingURL=index.js.map