@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/dist/cjs/src/auth/clients/AuthFetch.js

@@ -0,0 +1,734 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthFetch = void 0;
+// @ts-nocheck
+const Utils = __importStar(require("../../primitives/utils.js"));
+const Random_js_1 = __importDefault(require("../../primitives/Random.js"));
+const P2PKH_js_1 = __importDefault(require("../../script/templates/P2PKH.js"));
+const PublicKey_js_1 = __importDefault(require("../../primitives/PublicKey.js"));
+const createNonce_js_1 = require("../utils/createNonce.js");
+const Peer_js_1 = require("../Peer.js");
+const SimplifiedFetchTransport_js_1 = require("../transports/SimplifiedFetchTransport.js");
+const SessionManager_js_1 = require("../SessionManager.js");
+const index_js_1 = require("../utils/index.js");
+const PAYMENT_VERSION = '1.0';
+/**
+ * AuthFetch provides a lightweight fetch client for interacting with servers
+ * over a simplified HTTP transport mechanism. It integrates session management, peer communication,
+ * and certificate handling to enable secure and mutually-authenticated requests.
+ *
+ * Additionally, it automatically handles 402 Payment Required responses by creating
+ * and sending BSV payment transactions when necessary.
+ */
+class AuthFetch {
+    /**
+    * Constructs a new AuthFetch instance.
+    * @param wallet - The wallet instance for signing and authentication.
+    * @param requestedCertificates - Optional set of certificates to request from peers.
+    */
+    constructor(wallet, requestedCertificates, sessionManager, originator) {
+        this.callbacks = {};
+        this.certificatesReceived = [];
+        this.peers = {};
+        this.wallet = wallet;
+        this.requestedCertificates = requestedCertificates;
+        this.sessionManager = sessionManager ?? new SessionManager_js_1.SessionManager();
+        this.originator = originator;
+    }
+    /**
+     * Mutually authenticates and sends a HTTP request to a server.
+     *
+     * 1) Attempt the request.
+     * 2) If 402 Payment Required, automatically create and send payment.
+     * 3) Return the final response.
+     *
+     * @param url - The URL to send the request to.
+     * @param config - Configuration options for the request, including method, headers, and body.
+     * @returns A promise that resolves with the server's response, structured as a Response-like object.
+     *
+     * @throws Will throw an error if unsupported headers are used or other validation fails.
+     */
+    async fetch(url, config = {}) {
+        if (typeof config.retryCounter === 'number') {
+            if (config.retryCounter <= 0) {
+                throw new Error('Request failed after maximum number of retries.');
+            }
+            config.retryCounter--;
+        }
+        const response = await new Promise((async (resolve, reject) => {
+            try {
+                // Apply defaults
+                const { method = 'GET', headers = {}, body } = config;
+                // Extract a base url
+                const parsedUrl = new URL(url);
+                const baseURL = parsedUrl.origin;
+                // Create a new transport for this base url if needed
+                let peerToUse;
+                if (typeof this.peers[baseURL] === 'undefined') {
+                    // Create a peer for the request
+                    const newTransport = new SimplifiedFetchTransport_js_1.SimplifiedFetchTransport(baseURL);
+                    peerToUse = {
+                        peer: new Peer_js_1.Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager, undefined, this.originator),
+                        pendingCertificateRequests: []
+                    };
+                    this.peers[baseURL] = peerToUse;
+                    this.peers[baseURL].peer.listenForCertificatesReceived((senderPublicKey, certs) => {
+                        this.certificatesReceived.push(...certs);
+                    });
+                    this.peers[baseURL].peer.listenForCertificatesRequested((async (verifier, requestedCertificates) => {
+                        try {
+                            this.peers[baseURL].pendingCertificateRequests.push(true);
+                            const certificatesToInclude = await (0, index_js_1.getVerifiableCertificates)(this.wallet, requestedCertificates, verifier, this.originator);
+                            await this.peers[baseURL].peer.sendCertificateResponse(verifier, certificatesToInclude);
+                        }
+                        finally {
+                            // Give the backend 500 ms to process the certificates we just sent, before releasing the queue entry
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            this.peers[baseURL].pendingCertificateRequests.shift();
+                        }
+                    }));
+                }
+                else {
+                    // Check if there's a session associated with this baseURL
+                    if (this.peers[baseURL].supportsMutualAuth === false) {
+                        // Use standard fetch if mutual authentication is not supported
+                        try {
+                            const response = await this.handleFetchAndValidate(url, config, this.peers[baseURL]);
+                            resolve(response);
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                        return;
+                    }
+                    peerToUse = this.peers[baseURL];
+                }
+                // Serialize the simplified fetch request.
+                const requestNonce = (0, Random_js_1.default)(32);
+                const requestNonceAsBase64 = Utils.toBase64(requestNonce);
+                const writer = await this.serializeRequest(method, headers, body, parsedUrl, requestNonce);
+                // Setup general message listener to resolve requests once a response is received
+                this.callbacks[requestNonceAsBase64] = { resolve, reject };
+                const listenerId = peerToUse.peer.listenForGeneralMessages((senderPublicKey, payload) => {
+                    // Create a reader
+                    const responseReader = new Utils.Reader(payload);
+                    // Deserialize first 32 bytes of payload
+                    const responseNonceAsBase64 = Utils.toBase64(responseReader.read(32));
+                    if (responseNonceAsBase64 !== requestNonceAsBase64) {
+                        return;
+                    }
+                    peerToUse.peer.stopListeningForGeneralMessages(listenerId);
+                    // Save the identity key for the peer for future requests, since we have it here.
+                    this.peers[baseURL].identityKey = senderPublicKey;
+                    this.peers[baseURL].supportsMutualAuth = true;
+                    // Status code
+                    const statusCode = responseReader.readVarIntNum();
+                    // Headers
+                    const responseHeaders = {};
+                    const nHeaders = responseReader.readVarIntNum();
+                    if (nHeaders > 0) {
+                        for (let i = 0; i < nHeaders; i++) {
+                            const nHeaderKeyBytes = responseReader.readVarIntNum();
+                            const headerKeyBytes = responseReader.read(nHeaderKeyBytes);
+                            const headerKey = Utils.toUTF8(headerKeyBytes);
+                            const nHeaderValueBytes = responseReader.readVarIntNum();
+                            const headerValueBytes = responseReader.read(nHeaderValueBytes);
+                            const headerValue = Utils.toUTF8(headerValueBytes);
+                            responseHeaders[headerKey] = headerValue;
+                        }
+                    }
+                    // Add back the server identity key header
+                    responseHeaders['x-bsv-auth-identity-key'] = senderPublicKey;
+                    // Body
+                    let responseBody;
+                    const responseBodyBytes = responseReader.readVarIntNum();
+                    if (responseBodyBytes > 0) {
+                        responseBody = responseReader.read(responseBodyBytes);
+                    }
+                    // Create the Response object
+                    const responseValue = new Response(responseBody ? new Uint8Array(responseBody) : null, {
+                        status: statusCode,
+                        statusText: `${statusCode}`,
+                        headers: new Headers(responseHeaders)
+                    });
+                    // Resolve or reject the correct request with the response data
+                    this.callbacks[requestNonceAsBase64].resolve(responseValue);
+                    // Clean up
+                    delete this.callbacks[requestNonceAsBase64];
+                });
+                // Before sending general messages to the peer, ensure that no certificate requests are pending.
+                // This way, the user would need to choose to either allow or reject the certificate request first.
+                // If the server has a resource that requires certificates to be sent before access would be granted,
+                // this makes sure the user has a chance to send the certificates before the resource is requested.
+                if (peerToUse.pendingCertificateRequests.length > 0) {
+                    await new Promise(resolve => {
+                        setInterval(() => {
+                            if (peerToUse.pendingCertificateRequests.length === 0) {
+                                resolve();
+                            }
+                        }, 100); // Check every 100 ms for the user to finish responding
+                    });
+                }
+                // Send the request, now that all listeners are set up
+                await peerToUse.peer.toPeer(writer.toArray(), peerToUse.identityKey).catch(async (error) => {
+                    if (error.message.includes('Session not found for nonce')) {
+                        delete this.peers[baseURL];
+                        config.retryCounter ?? (config.retryCounter = 3);
+                        const response = await this.fetch(url, config);
+                        resolve(response);
+                        return;
+                    }
+                    if (error.message.includes('HTTP server failed to authenticate')) {
+                        try {
+                            const response = await this.handleFetchAndValidate(url, config, peerToUse);
+                            resolve(response);
+                            return;
+                        }
+                        catch (fetchError) {
+                            reject(fetchError);
+                        }
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        }));
+        // Check if server requires payment to access the requested route
+        if (response.status === 402) {
+            // Create and attach a payment, then retry
+            return await this.handlePaymentAndRetry(url, config, response);
+        }
+        return response;
+    }
+    /**
+     * Request Certificates from a Peer
+     * @param baseUrl
+     * @param certificatesToRequest
+     */
+    async sendCertificateRequest(baseUrl, certificatesToRequest) {
+        const parsedUrl = new URL(baseUrl);
+        const baseURL = parsedUrl.origin;
+        let peerToUse;
+        if (typeof this.peers[baseURL] !== 'undefined') {
+            peerToUse = { peer: this.peers[baseURL].peer };
+        }
+        else {
+            const newTransport = new SimplifiedFetchTransport_js_1.SimplifiedFetchTransport(baseURL);
+            peerToUse = {
+                peer: new Peer_js_1.Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager, this.originator)
+            };
+            this.peers[baseURL] = peerToUse;
+        }
+        // Return a promise that resolves when certificates are received
+        return await new Promise((async (resolve, reject) => {
+            // Set up the listener before making the request
+            const callbackId = peerToUse.peer.listenForCertificatesReceived((_senderPublicKey, certs) => {
+                peerToUse.peer.stopListeningForCertificatesReceived(callbackId);
+                this.certificatesReceived.push(...certs);
+                resolve(certs);
+            });
+            try {
+                // Initiate the certificate request
+                await peerToUse.peer.requestCertificates(certificatesToRequest, peerToUse.identityKey);
+            }
+            catch (err) {
+                peerToUse.peer.stopListeningForCertificatesReceived(callbackId);
+                reject(err);
+            }
+        }));
+    }
+    /**
+     * Return any certificates we've collected thus far, then clear them out.
+     */
+    consumeReceivedCertificates() {
+        return this.certificatesReceived.splice(0);
+    }
+    /**
+     * Serializes the HTTP request to be sent over the Transport.
+     *
+     * @param method - The HTTP method (e.g., 'GET', 'POST') for the request.
+     * @param headers - A record of HTTP headers to include in the request.
+     * @param body - The body of the request, if applicable (e.g., for POST/PUT requests).
+     * @param parsedUrl - The parsed URL object containing the full request URL.
+     * @param requestNonce - A unique random nonce to ensure request integrity.
+     * @returns A promise that resolves to a `Writer` containing the serialized request.
+     *
+     * @throws Will throw an error if unsupported headers are used or serialization fails.
+     */
+    async serializeRequest(method, headers, body, parsedUrl, requestNonce) {
+        const writer = new Utils.Writer();
+        // Write request nonce
+        writer.write(requestNonce);
+        // Method length
+        writer.writeVarIntNum(method.length);
+        // Method
+        writer.write(Utils.toArray(method));
+        // Handle pathname (e.g. /path/to/resource)
+        if (parsedUrl.pathname.length > 0) {
+            // Pathname length
+            const pathnameAsArray = Utils.toArray(parsedUrl.pathname);
+            writer.writeVarIntNum(pathnameAsArray.length);
+            // Pathname
+            writer.write(pathnameAsArray);
+        }
+        else {
+            writer.writeVarIntNum(-1);
+        }
+        // Handle search params (e.g. ?q=hello)
+        if (parsedUrl.search.length > 0) {
+            // search length
+            const searchAsArray = Utils.toArray(parsedUrl.search);
+            writer.writeVarIntNum(searchAsArray.length);
+            // search
+            writer.write(searchAsArray);
+        }
+        else {
+            writer.writeVarIntNum(-1);
+        }
+        // Construct headers to send / sign:
+        // Ensures clients only provided supported HTTP request headers
+        // - Include custom headers prefixed with x-bsv (excluding those starting with x-bsv-auth)
+        // - Include a normalized version of the content-type header
+        // - Include the authorization header
+        const includedHeaders = [];
+        for (let [k, v] of Object.entries(headers)) {
+            k = k.toLowerCase(); // We will always sign lower-case header keys
+            if (k.startsWith('x-bsv-') || k === 'authorization') {
+                if (k.startsWith('x-bsv-auth')) {
+                    throw new Error('No BSV auth headers allowed here!');
+                }
+                includedHeaders.push([k, v]);
+            }
+            else if (k.startsWith('content-type')) {
+                // Normalize the Content-Type header by removing any parameters (e.g., "; charset=utf-8")
+                v = v.split(';')[0].trim();
+                includedHeaders.push([k, v]);
+            }
+            else {
+                throw new Error('Unsupported header in the simplified fetch implementation. Only content-type, authorization, and x-bsv-* headers are supported.');
+            }
+        }
+        // Sort the headers by key to ensure a consistent order for signing and verification.
+        includedHeaders.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+        // nHeaders
+        writer.writeVarIntNum(includedHeaders.length);
+        for (let i = 0; i < includedHeaders.length; i++) {
+            // headerKeyLength
+            const headerKeyAsArray = Utils.toArray(includedHeaders[i][0], 'utf8');
+            writer.writeVarIntNum(headerKeyAsArray.length);
+            // headerKey
+            writer.write(headerKeyAsArray);
+            // headerValueLength
+            const headerValueAsArray = Utils.toArray(includedHeaders[i][1], 'utf8');
+            writer.writeVarIntNum(headerValueAsArray.length);
+            // headerValue
+            writer.write(headerValueAsArray);
+        }
+        // If method typically carries a body and body is undefined, default it
+        // This prevents signature verification errors due to mismatch default body types with express
+        const methodsThatTypicallyHaveBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
+        if (methodsThatTypicallyHaveBody.includes(method.toUpperCase()) && body === undefined) {
+            // Check if content-type is application/json
+            const contentTypeHeader = includedHeaders.find(([k]) => k === 'content-type');
+            if (contentTypeHeader && contentTypeHeader[1].includes('application/json')) {
+                body = '{}';
+            }
+            else {
+                body = '';
+            }
+        }
+        // Handle body
+        if (body) {
+            const reqBody = await this.normalizeBodyToNumberArray(body); // Use the utility function
+            writer.writeVarIntNum(reqBody.length);
+            writer.write(reqBody);
+        }
+        else {
+            writer.writeVarIntNum(-1); // No body
+        }
+        return writer;
+    }
+    /**
+     * Handles a non-authenticated fetch requests and validates that the server is not claiming to be authenticated.
+     */
+    async handleFetchAndValidate(url, config, peerToUse) {
+        const response = await fetch(url, config);
+        response.headers.forEach(header => {
+            if (header.toLocaleLowerCase().startsWith('x-bsv')) {
+                throw new Error('The server is trying to claim it has been authenticated when it has not!');
+            }
+        });
+        if (response.ok) {
+            peerToUse.supportsMutualAuth = false;
+            return response;
+        }
+        else {
+            throw new Error(`Request failed with status: ${response.status}`);
+        }
+    }
+    /**
+     * If we get 402 Payment Required, we build a transaction via wallet.createAction()
+     * and re-attempt the request with an x-bsv-payment header.
+     */
+    async handlePaymentAndRetry(url, config = {}, originalResponse) {
+        const paymentVersion = originalResponse.headers.get('x-bsv-payment-version');
+        if (!paymentVersion || paymentVersion !== PAYMENT_VERSION) {
+            throw new Error(`Unsupported x-bsv-payment-version response header. Client version: ${PAYMENT_VERSION}, Server version: ${paymentVersion}`);
+        }
+        const satoshisRequiredHeader = originalResponse.headers.get('x-bsv-payment-satoshis-required');
+        if (!satoshisRequiredHeader) {
+            throw new Error('Missing x-bsv-payment-satoshis-required response header.');
+        }
+        const satoshisRequired = parseInt(satoshisRequiredHeader);
+        if (isNaN(satoshisRequired) || satoshisRequired <= 0) {
+            throw new Error('Invalid x-bsv-payment-satoshis-required response header value.');
+        }
+        const serverIdentityKey = originalResponse.headers.get('x-bsv-auth-identity-key');
+        if (typeof serverIdentityKey !== 'string') {
+            throw new Error('Missing x-bsv-auth-identity-key response header.');
+        }
+        const derivationPrefix = originalResponse.headers.get('x-bsv-payment-derivation-prefix');
+        if (typeof derivationPrefix !== 'string' || derivationPrefix.length < 1) {
+            throw new Error('Missing x-bsv-payment-derivation-prefix response header.');
+        }
+        let paymentContext = config.paymentContext;
+        if (paymentContext != null) {
+            const requirementsChanged = !this.isPaymentContextCompatible(paymentContext, satoshisRequired, serverIdentityKey, derivationPrefix);
+            if (requirementsChanged) {
+                this.logPaymentAttempt('warn', 'Server adjusted payment requirements; regenerating transaction', this.composePaymentLogDetails(url, paymentContext));
+                paymentContext = await this.createPaymentContext(url, config, satoshisRequired, serverIdentityKey, derivationPrefix);
+            }
+        }
+        else {
+            paymentContext = await this.createPaymentContext(url, config, satoshisRequired, serverIdentityKey, derivationPrefix);
+        }
+        if (paymentContext.attempts >= paymentContext.maxAttempts) {
+            throw this.buildPaymentFailureError(url, paymentContext, new Error('Maximum payment attempts exceeded before retrying'));
+        }
+        const headersWithPayment = {
+            ...(config.headers ?? {})
+        };
+        headersWithPayment['x-bsv-payment'] = JSON.stringify({
+            derivationPrefix: paymentContext.derivationPrefix,
+            derivationSuffix: paymentContext.derivationSuffix,
+            transaction: paymentContext.transactionBase64
+        });
+        const nextConfig = {
+            ...config,
+            headers: headersWithPayment,
+            paymentContext
+        };
+        if (typeof nextConfig.retryCounter !== 'number') {
+            nextConfig.retryCounter = 3;
+        }
+        const attemptNumber = paymentContext.attempts + 1;
+        const maxAttempts = paymentContext.maxAttempts;
+        paymentContext.attempts = attemptNumber;
+        const attemptDetails = this.composePaymentLogDetails(url, paymentContext);
+        this.logPaymentAttempt('warn', `Attempting paid request (${attemptNumber}/${maxAttempts})`, attemptDetails);
+        try {
+            const response = await this.fetch(url, nextConfig);
+            this.logPaymentAttempt('info', `Paid request attempt ${attemptNumber} succeeded`, attemptDetails);
+            return response;
+        }
+        catch (error) {
+            const errorEntry = this.createPaymentErrorEntry(paymentContext.attempts, error);
+            paymentContext.errors.push(errorEntry);
+            this.logPaymentAttempt('error', `Paid request attempt ${attemptNumber} failed`, {
+                ...attemptDetails,
+                error: {
+                    message: errorEntry.message,
+                    stack: errorEntry.stack
+                }
+            });
+            if (paymentContext.attempts >= paymentContext.maxAttempts) {
+                throw this.buildPaymentFailureError(url, paymentContext, error);
+            }
+            const delayMs = this.getPaymentRetryDelay(paymentContext.attempts);
+            await this.wait(delayMs);
+            return this.handlePaymentAndRetry(url, nextConfig, originalResponse);
+        }
+    }
+    isPaymentContextCompatible(context, satoshisRequired, serverIdentityKey, derivationPrefix) {
+        return (context.satoshisRequired === satoshisRequired &&
+            context.serverIdentityKey === serverIdentityKey &&
+            context.derivationPrefix === derivationPrefix);
+    }
+    async createPaymentContext(url, config, satoshisRequired, serverIdentityKey, derivationPrefix) {
+        const derivationSuffix = await (0, createNonce_js_1.createNonce)(this.wallet, undefined, this.originator);
+        const { publicKey: derivedPublicKey } = await this.wallet.getPublicKey({
+            protocolID: [2, '3241645161d8'],
+            keyID: `${derivationPrefix} ${derivationSuffix}`,
+            counterparty: serverIdentityKey
+        }, this.originator);
+        const lockingScript = new P2PKH_js_1.default().lock(PublicKey_js_1.default.fromString(derivedPublicKey).toAddress()).toHex();
+        const { tx } = await this.wallet.createAction({
+            description: `Payment for request to ${new URL(url).origin}`,
+            outputs: [{
+                    satoshis: satoshisRequired,
+                    lockingScript,
+                    customInstructions: JSON.stringify({ derivationPrefix, derivationSuffix, payee: serverIdentityKey }),
+                    outputDescription: 'HTTP request payment'
+                }],
+            options: {
+                randomizeOutputs: false
+            }
+        }, this.originator);
+        const { publicKey: clientIdentityKey } = await this.wallet.getPublicKey({ identityKey: true }, this.originator);
+        return {
+            satoshisRequired,
+            transactionBase64: Utils.toBase64(tx),
+            derivationPrefix,
+            derivationSuffix,
+            serverIdentityKey,
+            clientIdentityKey,
+            attempts: 0,
+            maxAttempts: this.getMaxPaymentAttempts(config),
+            errors: [],
+            requestSummary: this.buildPaymentRequestSummary(url, config)
+        };
+    }
+    getMaxPaymentAttempts(config) {
+        const attempts = typeof config.paymentRetryAttempts === 'number' ? config.paymentRetryAttempts : undefined;
+        if (typeof attempts === 'number' && attempts > 0) {
+            return Math.floor(attempts);
+        }
+        return 3;
+    }
+    buildPaymentRequestSummary(url, config) {
+        const headers = { ...(config.headers ?? {}) };
+        const method = typeof config.method === 'string' ? config.method.toUpperCase() : 'GET';
+        const bodySummary = this.describeRequestBodyForLogging(config.body);
+        return {
+            url,
+            method,
+            headers,
+            bodyType: bodySummary.type,
+            bodyByteLength: bodySummary.byteLength
+        };
+    }
+    describeRequestBodyForLogging(body) {
+        if (body == null) {
+            return { type: 'none', byteLength: 0 };
+        }
+        if (typeof body === 'string') {
+            return { type: 'string', byteLength: Utils.toArray(body, 'utf8').length };
+        }
+        if (Array.isArray(body)) {
+            if (body.every((item) => typeof item === 'number')) {
+                return { type: 'number[]', byteLength: body.length };
+            }
+            return { type: 'array', byteLength: body.length };
+        }
+        if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) {
+            return { type: 'ArrayBuffer', byteLength: body.byteLength };
+        }
+        if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(body)) {
+            return {
+                type: body.constructor != null ? body.constructor.name : 'TypedArray',
+                byteLength: body.byteLength
+            };
+        }
+        if (typeof Blob !== 'undefined' && body instanceof Blob) {
+            return { type: 'Blob', byteLength: body.size };
+        }
+        if (typeof FormData !== 'undefined' && body instanceof FormData) {
+            return { type: 'FormData', byteLength: 0 };
+        }
+        if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) {
+            const serialized = body.toString();
+            return { type: 'URLSearchParams', byteLength: Utils.toArray(serialized, 'utf8').length };
+        }
+        if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+            return { type: 'ReadableStream', byteLength: 0 };
+        }
+        try {
+            const serialized = JSON.stringify(body);
+            if (typeof serialized === 'string') {
+                return { type: 'object', byteLength: Utils.toArray(serialized, 'utf8').length };
+            }
+        }
+        catch (_) {
+            // Ignore JSON serialization issues for logging purposes.
+        }
+        return { type: typeof body, byteLength: 0 };
+    }
+    composePaymentLogDetails(url, context) {
+        return {
+            url,
+            request: context.requestSummary,
+            payment: {
+                satoshis: context.satoshisRequired,
+                transactionBase64: context.transactionBase64,
+                derivationPrefix: context.derivationPrefix,
+                derivationSuffix: context.derivationSuffix,
+                serverIdentityKey: context.serverIdentityKey,
+                clientIdentityKey: context.clientIdentityKey
+            },
+            attempts: {
+                used: context.attempts,
+                max: context.maxAttempts
+            },
+            errors: context.errors
+        };
+    }
+    logPaymentAttempt(level, message, details) {
+        const prefix = '[AuthFetch][Payment]';
+        if (level === 'error') {
+            console.error(`${prefix} ${message}`, details);
+        }
+        else if (level === 'warn') {
+            console.warn(`${prefix} ${message}`, details);
+        }
+        else {
+            if (typeof console.info === 'function') {
+                console.info(`${prefix} ${message}`, details);
+            }
+            else {
+                console.log(`${prefix} ${message}`, details);
+            }
+        }
+    }
+    createPaymentErrorEntry(attempt, error) {
+        const entry = {
+            attempt,
+            timestamp: new Date().toISOString(),
+            message: '',
+            stack: undefined
+        };
+        if (error instanceof Error) {
+            entry.message = error.message;
+            entry.stack = error.stack ?? undefined;
+        }
+        else {
+            entry.message = String(error);
+        }
+        return entry;
+    }
+    getPaymentRetryDelay(attempt) {
+        const baseDelay = 250;
+        const multiplier = Math.min(attempt, 5);
+        return baseDelay * multiplier;
+    }
+    async wait(ms) {
+        if (ms <= 0) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, ms));
+    }
+    buildPaymentFailureError(url, context, lastError) {
+        const message = `Paid request to ${url} failed after ${context.attempts}/${context.maxAttempts} attempts. Sent ${context.satoshisRequired} satoshis to ${context.serverIdentityKey}.`;
+        const error = new Error(message);
+        const failureDetails = {
+            request: context.requestSummary,
+            payment: {
+                satoshis: context.satoshisRequired,
+                transactionBase64: context.transactionBase64,
+                derivationPrefix: context.derivationPrefix,
+                derivationSuffix: context.derivationSuffix,
+                serverIdentityKey: context.serverIdentityKey,
+                clientIdentityKey: context.clientIdentityKey
+            },
+            attempts: {
+                used: context.attempts,
+                max: context.maxAttempts
+            },
+            errors: context.errors
+        };
+        error.details = failureDetails;
+        if (lastError instanceof Error) {
+            ;
+            error.cause = lastError;
+        }
+        return error;
+    }
+    async normalizeBodyToNumberArray(body) {
+        // 0. Null / undefined
+        if (body == null) {
+            return [];
+        }
+        // 1. object
+        if (typeof body === 'object') {
+            return Utils.toArray(JSON.stringify(body, 'utf8'));
+        }
+        // 2. number[]
+        if (Array.isArray(body) && body.every((item) => typeof item === 'number')) {
+            return body; // Return the array as is
+        }
+        // 3. string
+        if (typeof body === 'string') {
+            return Utils.toArray(body, 'utf8');
+        }
+        // 4. ArrayBuffer / TypedArrays
+        if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+            const typedArray = body instanceof ArrayBuffer ? new Uint8Array(body) : new Uint8Array(body.buffer);
+            return Array.from(typedArray);
+        }
+        // 5. Blob
+        if (body instanceof Blob) {
+            const arrayBuffer = await body.arrayBuffer();
+            return Array.from(new Uint8Array(arrayBuffer));
+        }
+        // 6. FormData
+        if (body instanceof FormData) {
+            const entries = [];
+            body.forEach((value, key) => {
+                entries.push([key, value.toString()]);
+            });
+            const urlEncoded = new URLSearchParams(entries).toString();
+            return Utils.toArray(urlEncoded, 'utf8');
+        }
+        // 7. URLSearchParams
+        if (body instanceof URLSearchParams) {
+            return Utils.toArray(body.toString(), 'utf8');
+        }
+        // 8. ReadableStream
+        if (body instanceof ReadableStream) {
+            throw new Error('ReadableStream cannot be directly converted to number[].');
+        }
+        // 9. Fallback
+        throw new Error('Unsupported body type in this SimplifiedFetch implementation.');
+    }
+}
+exports.AuthFetch = AuthFetch;
+//# sourceMappingURL=AuthFetch.js.map