@ardrive/turbo-sdk 1.36.0 → 1.37.0

package/lib/cjs/cli/options.js

@@ -186,6 +186,11 @@ exports.optionMap = {
         description: 'Enable on-demand crypto top-ups during upload if balance is insufficient',
         default: false,
     },
+    x402: {
+        alias: '--x402',
+        description: 'Pay for the action using x402 funding (if available). Requires token `base-usdc`.',
+        default: false,
+    },
     topUpBufferMultiplier: {
         alias: '--top-up-buffer-multiplier <topUpBufferMultiplier>',
         description: 'Multiplier to apply to the estimated top-up amount to avoid underpayment during on-demand top-ups. Defaults to 1.1 (10% buffer).',
@@ -215,6 +220,7 @@ const onDemandOptions = [
     exports.optionMap.onDemand,
     exports.optionMap.topUpBufferMultiplier,
     exports.optionMap.maxCryptoTopUpValue,
+    exports.optionMap.x402,
 ];
 exports.uploadOptions = [
     ...exports.walletOptions,

package/lib/cjs/cli/utils.js

@@ -270,7 +270,10 @@ function getTagsFromOptions(options) {
     return parseTags(options.tags);
 }
 function onDemandOptionsFromOptions(options) {
-    if (!options.onDemand) {
+    if (options.x402 && options.onDemand) {
+        throw new Error('Cannot use both --x402 and --on-demand flags');
+    }
+    if (!options.onDemand && !options.x402) {
         return { fundingMode: new index_js_1.ExistingBalanceFunding() };
     }
     const value = options.maxCryptoTopUpValue;
@@ -282,6 +285,11 @@ function onDemandOptionsFromOptions(options) {
         const token = tokenFromOptions(options);
         maxTokenAmount = index_js_1.tokenToBaseMap[token](value).toString();
     }
+    if (options.x402) {
+        return {
+            fundingMode: new index_js_1.X402Funding({ maxMUSDCAmount: maxTokenAmount }),
+        };
+    }
     if (options.topUpBufferMultiplier !== undefined &&
         (isNaN(options.topUpBufferMultiplier) || options.topUpBufferMultiplier < 1)) {
         throw new Error('topUpBufferMultiplier must be a number >= 1');

package/lib/cjs/common/http.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboHTTPService = void 0;
+exports.toX402FetchBody = toX402FetchBody;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -18,6 +19,7 @@ exports.TurboHTTPService = void 0;
  */
 const axios_1 = require("axios");
 const node_stream_1 = require("node:stream");
+const x402_fetch_1 = require("x402-fetch");
 const axiosClient_js_1 = require("../utils/axiosClient.js");
 const common_js_1 = require("../utils/common.js");
 const errors_js_1 = require("../utils/errors.js");
@@ -36,7 +38,46 @@ class TurboHTTPService {
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
         return this.retryRequest(() => this.axios.get(endpoint, { headers, signal }), allowedStatuses);
     }
-    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, x402Options, }) {
+        if (x402Options !== undefined) {
+            this.logger.debug('Using X402 options for POST request', {
+                endpoint,
+                x402Options,
+            });
+            const { body, duplex } = await toX402FetchBody(data);
+            try {
+                const maxMUSDCAmount = x402Options.maxMUSDCAmount !== undefined
+                    ? BigInt(x402Options.maxMUSDCAmount.toString())
+                    : undefined;
+                const fetchWithPay = (0, x402_fetch_1.wrapFetchWithPayment)(fetch, x402Options.signer, maxMUSDCAmount);
+                const res = await fetchWithPay(this.axios.defaults.baseURL + '/x402/data-item/signed', {
+                    method: 'POST',
+                    headers,
+                    body,
+                    signal,
+                    ...(duplex ? { duplex } : {}), // Use duplex only where streams are working
+                });
+                if (!allowedStatuses.includes(res.status)) {
+                    const errorText = await res.text();
+                    throw new errors_js_1.FailedRequestError(
+                    // Return error message from server if available
+                    errorText || res.statusText, res.status);
+                }
+                return res.json();
+            }
+            catch (error) {
+                if (error instanceof errors_js_1.FailedRequestError) {
+                    throw error; // rethrow FailedRequestError
+                }
+                // Handle CanceledError specifically
+                if (error.message.includes('The operation was aborted')) {
+                    throw new axios_1.CanceledError();
+                }
+                // Log the error and throw a FailedRequestError
+                this.logger.error('Error posting data', { endpoint, error });
+                throw new errors_js_1.FailedRequestError(error instanceof Error ? error.message : 'Unknown error', error.response?.status);
+            }
+        }
         // Buffer and Readable → keep Axios (streams work fine there)
         if (!(data instanceof ReadableStream)) {
             if (data instanceof node_stream_1.Readable) {
@@ -141,3 +182,79 @@ async function toFetchBody(data) {
     const blob = await new Response(data).blob();
     return { body: blob }; // browser sets length
 }
+const isNode = typeof process !== 'undefined' && !!process.versions?.node;
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+function isFirefoxOrSafari() {
+    if (!isBrowser)
+        return false;
+    const ua = navigator.userAgent;
+    return ua.includes('Firefox') || ua.includes('Safari');
+}
+/** Create a re-usable body for x402 fetch protocol */
+async function toX402FetchBody(data) {
+    //
+    // 🔹 NODE: always buffer to a non-stream body (Buffer)
+    //         so fetchWithPayment can reuse it safely.
+    //
+    if (isNode) {
+        let buf;
+        // Web ReadableStream → Buffer
+        if (typeof ReadableStream !== 'undefined' &&
+            data instanceof ReadableStream) {
+            const ab = await new Response(data).arrayBuffer();
+            buf = Buffer.from(ab);
+        }
+        // Node Readable → Buffer
+        else if (data instanceof node_stream_1.Readable) {
+            const chunks = [];
+            for await (const chunk of data) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            buf = Buffer.concat(chunks.map((c) => Uint8Array.from(c)));
+        }
+        // Buffer / Uint8Array
+        else if (Buffer.isBuffer(data)) {
+            buf = data;
+        }
+        else if (data instanceof Uint8Array) {
+            buf = Buffer.from(data);
+        }
+        else {
+            throw new Error('Unsupported body type for toFetchBody (Node)');
+        }
+        // For Buffer body, Node *does not* need duplex.
+        return { body: buf };
+    }
+    //
+    // 🔹 BROWSER: keep your previous behavior (streams/Blob), no duplex.
+    //
+    let body;
+    // Already a web ReadableStream
+    if (typeof ReadableStream !== 'undefined' && data instanceof ReadableStream) {
+        body = data;
+    }
+    // Node Readable in browser (rare, but be safe) → Blob
+    else if (data instanceof node_stream_1.Readable) {
+        const chunks = [];
+        for await (const chunk of data) {
+            const buf = typeof chunk === 'string'
+                ? new TextEncoder().encode(chunk)
+                : new Uint8Array(chunk);
+            chunks.push(buf);
+        }
+        body = new Blob(chunks);
+    }
+    // Buffer / Uint8Array
+    else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        body = new Blob([Uint8Array.from(data)]);
+    }
+    else {
+        throw new Error('Unsupported body type for toFetchBody (browser)');
+    }
+    // Firefox / Safari – avoid streaming uploads
+    if (isFirefoxOrSafari() && body instanceof ReadableStream) {
+        const blob = await new Response(body).blob();
+        return { body: blob };
+    }
+    return { body };
+}

package/lib/cjs/common/signer.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboDataItemAbstractSigner = void 0;
+exports.makeX402Signer = makeX402Signer;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -31,6 +32,9 @@ const crypto_2 = require("crypto");
 const ethers_1 = require("ethers");
 const ethers_2 = require("ethers");
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const chains_1 = require("viem/chains");
 const types_js_1 = require("../types.js");
 const base64_js_1 = require("../utils/base64.js");
 const logger_js_1 = require("./logger.js");
@@ -155,3 +159,34 @@ class TurboDataItemAbstractSigner {
     }
 }
 exports.TurboDataItemAbstractSigner = TurboDataItemAbstractSigner;
+async function makeX402Signer(arbundlesSigner) {
+    // Node: our SDK uses EthereumSigner with a raw private key
+    if (arbundlesSigner instanceof arbundles_1.EthereumSigner) {
+        return (0, viem_1.createWalletClient)({
+            account: (0, accounts_1.privateKeyToAccount)(('0x' +
+                Buffer.from(arbundlesSigner.key).toString('hex'))),
+            chain: chains_1.baseSepolia,
+            transport: (0, viem_1.http)(),
+        });
+    }
+    // Browser: use injected wallet + selected account
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof window !== 'undefined' && window.ethereum) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const provider = window.ethereum;
+        // ask wallet for an account
+        const accounts = (await provider.request({
+            method: 'eth_requestAccounts',
+        }));
+        if (accounts === undefined || accounts.length === 0) {
+            throw new Error('No accounts returned from wallet');
+        }
+        const account = accounts[0];
+        return (0, viem_1.createWalletClient)({
+            account,
+            chain: chains_1.baseSepolia,
+            transport: (0, viem_1.custom)(provider),
+        });
+    }
+    throw new Error('Unable to construct x402 signer for x402 options');
+}

package/lib/cjs/common/upload.js

@@ -28,6 +28,7 @@ const events_js_1 = require("./events.js");
 const http_js_1 = require("./http.js");
 const index_js_1 = require("./index.js");
 const logger_js_1 = require("./logger.js");
+const signer_js_1 = require("./signer.js");
 function isTurboUploadFileWithStreamFactoryParams(params) {
     return 'fileStreamFactory' in params;
 }
@@ -53,7 +54,7 @@ class TurboUnauthenticatedUploadService {
         });
         this.retryConfig = retryConfig;
     }
-    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, dataItemOpts, signal, events = {}, }) {
+    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, dataItemOpts, signal, events = {}, x402Options, }) {
         const dataItemSize = dataItemSizeFactory();
         this.logger.debug('Uploading signed data item...');
         // create the tapped stream with events
@@ -83,6 +84,7 @@ class TurboUnauthenticatedUploadService {
             signal,
             data: streamWithUploadEvents,
             headers,
+            x402Options,
         });
         // resume the stream so events start flowing to the post
         resume();
@@ -94,6 +96,7 @@ exports.TurboUnauthenticatedUploadService = TurboUnauthenticatedUploadService;
 class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadService {
     constructor({ url = exports.defaultUploadServiceURL, retryConfig, signer, logger, token, paymentService, }) {
         super({ url, retryConfig, logger, token });
+        this.x402EnabledTokens = ['base-usdc'];
         this.enabledOnDemandTokens = [
             'ario',
             'solana',
@@ -176,6 +179,14 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
     }
     async uploadFile(params) {
         const { signal, dataItemOpts, events, fileStreamFactory, fileSizeFactory, fundingMode = new types_js_1.ExistingBalanceFunding(), } = this.resolveUploadFileConfig(params);
+        if (fundingMode instanceof types_js_1.X402Funding &&
+            !this.x402EnabledTokens.includes(this.token)) {
+            throw new Error('x402 uploads are not supported for token: ' + this.token);
+        }
+        if (params.chunkingMode === 'force' && fundingMode instanceof types_js_1.X402Funding) {
+            throw new Error("Chunking mode 'force' is not supported when x402 is enabled");
+        }
+        this.logger.debug('Starting file upload', { params });
         let retries = 0;
         const maxRetries = this.retryConfig.retries ?? 3;
         const retryDelay = this.retryConfig.retryDelay ??
@@ -220,7 +231,8 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                     chunkingMode: params.chunkingMode,
                     maxFinalizeMs: params.maxFinalizeMs,
                 });
-                if (chunkedUploader.shouldUseChunkUploader) {
+                if (chunkedUploader.shouldUseChunkUploader &&
+                    !(fundingMode instanceof types_js_1.X402Funding)) {
                     const response = await chunkedUploader.upload({
                         dataItemStreamFactory,
                         dataItemSizeFactory,
@@ -230,12 +242,20 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                     });
                     return { ...response, cryptoFundResult };
                 }
+                const x402Options = fundingMode instanceof types_js_1.X402Funding
+                    ? {
+                        signer: fundingMode.signer ??
+                            (await (0, signer_js_1.makeX402Signer)(this.signer.signer)),
+                        maxMUSDCAmount: fundingMode.maxMUSDCAmount,
+                    }
+                    : undefined;
                 const response = await this.uploadSignedDataItem({
                     dataItemStreamFactory,
                     dataItemSizeFactory,
                     dataItemOpts,
                     signal,
                     events,
+                    x402Options,
                 });
                 return { ...response, cryptoFundResult };
             }
@@ -387,6 +407,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                             });
                         },
                     },
+                    fundingMode,
                 });
                 const relativePath = this.getRelativePath(file, params);
                 paths[relativePath] = { id: result.id };
@@ -479,6 +500,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             maxChunkConcurrency,
             maxFinalizeMs,
             chunkingMode,
+            fundingMode,
         });
         emitter.emit('folder-success');
         return {

package/lib/cjs/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.OnDemandFunding = exports.ExistingBalanceFunding = exports.supportedEvmSignerTokens = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
+exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.X402Funding = exports.OnDemandFunding = exports.ExistingBalanceFunding = exports.supportedEvmSignerTokens = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
 exports.isCurrency = isCurrency;
 exports.isKyvePrivateKey = isKyvePrivateKey;
 exports.isEthPrivateKey = isEthPrivateKey;
@@ -62,6 +62,14 @@ class OnDemandFunding {
     }
 }
 exports.OnDemandFunding = OnDemandFunding;
+class X402Funding {
+    constructor({ signer, maxMUSDCAmount, }) {
+        this.signer = signer;
+        this.maxMUSDCAmount =
+            maxMUSDCAmount !== undefined ? new bignumber_js_1.BigNumber(maxMUSDCAmount) : undefined;
+    }
+}
+exports.X402Funding = X402Funding;
 exports.multipartPendingStatus = [
     'ASSEMBLING',
     'VALIDATING',

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '1.36.0';
+exports.version = '1.37.0';

package/lib/esm/cli/options.js

@@ -183,6 +183,11 @@ export const optionMap = {
         description: 'Enable on-demand crypto top-ups during upload if balance is insufficient',
         default: false,
     },
+    x402: {
+        alias: '--x402',
+        description: 'Pay for the action using x402 funding (if available). Requires token `base-usdc`.',
+        default: false,
+    },
     topUpBufferMultiplier: {
         alias: '--top-up-buffer-multiplier <topUpBufferMultiplier>',
         description: 'Multiplier to apply to the estimated top-up amount to avoid underpayment during on-demand top-ups. Defaults to 1.1 (10% buffer).',
@@ -212,6 +217,7 @@ const onDemandOptions = [
     optionMap.onDemand,
     optionMap.topUpBufferMultiplier,
     optionMap.maxCryptoTopUpValue,
+    optionMap.x402,
 ];
 export const uploadOptions = [
     ...walletOptions,

package/lib/esm/cli/utils.js

@@ -15,7 +15,7 @@
  */
 import bs58 from 'bs58';
 import { readFileSync, statSync } from 'fs';
-import { ExistingBalanceFunding, OnDemandFunding, TurboFactory, defaultTurboConfiguration, developmentTurboConfiguration, fiatCurrencyTypes, isCurrency, isTokenType, privateKeyFromKyveMnemonic, tokenToBaseMap, } from '../node/index.js';
+import { ExistingBalanceFunding, OnDemandFunding, TurboFactory, X402Funding, defaultTurboConfiguration, developmentTurboConfiguration, fiatCurrencyTypes, isCurrency, isTokenType, privateKeyFromKyveMnemonic, tokenToBaseMap, } from '../node/index.js';
 import { defaultProdAoConfigs, tokenToDevAoConfigMap, tokenToDevGatewayMap, } from '../utils/common.js';
 import { NoWalletProvidedError } from './errors.js';
 export function exitWithErrorLog(error) {
@@ -246,7 +246,10 @@ export function getTagsFromOptions(options) {
     return parseTags(options.tags);
 }
 export function onDemandOptionsFromOptions(options) {
-    if (!options.onDemand) {
+    if (options.x402 && options.onDemand) {
+        throw new Error('Cannot use both --x402 and --on-demand flags');
+    }
+    if (!options.onDemand && !options.x402) {
         return { fundingMode: new ExistingBalanceFunding() };
     }
     const value = options.maxCryptoTopUpValue;
@@ -258,6 +261,11 @@ export function onDemandOptionsFromOptions(options) {
         const token = tokenFromOptions(options);
         maxTokenAmount = tokenToBaseMap[token](value).toString();
     }
+    if (options.x402) {
+        return {
+            fundingMode: new X402Funding({ maxMUSDCAmount: maxTokenAmount }),
+        };
+    }
     if (options.topUpBufferMultiplier !== undefined &&
         (isNaN(options.topUpBufferMultiplier) || options.topUpBufferMultiplier < 1)) {
         throw new Error('topUpBufferMultiplier must be a number >= 1');

package/lib/esm/common/http.js

@@ -15,6 +15,7 @@
  */
 import { AxiosError, CanceledError } from 'axios';
 import { Readable } from 'node:stream';
+import { wrapFetchWithPayment } from 'x402-fetch';
 import { createAxiosInstance, defaultRetryConfig, } from '../utils/axiosClient.js';
 import { sleep } from '../utils/common.js';
 import { FailedRequestError } from '../utils/errors.js';
@@ -33,7 +34,46 @@ export class TurboHTTPService {
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
         return this.retryRequest(() => this.axios.get(endpoint, { headers, signal }), allowedStatuses);
     }
-    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, x402Options, }) {
+        if (x402Options !== undefined) {
+            this.logger.debug('Using X402 options for POST request', {
+                endpoint,
+                x402Options,
+            });
+            const { body, duplex } = await toX402FetchBody(data);
+            try {
+                const maxMUSDCAmount = x402Options.maxMUSDCAmount !== undefined
+                    ? BigInt(x402Options.maxMUSDCAmount.toString())
+                    : undefined;
+                const fetchWithPay = wrapFetchWithPayment(fetch, x402Options.signer, maxMUSDCAmount);
+                const res = await fetchWithPay(this.axios.defaults.baseURL + '/x402/data-item/signed', {
+                    method: 'POST',
+                    headers,
+                    body,
+                    signal,
+                    ...(duplex ? { duplex } : {}), // Use duplex only where streams are working
+                });
+                if (!allowedStatuses.includes(res.status)) {
+                    const errorText = await res.text();
+                    throw new FailedRequestError(
+                    // Return error message from server if available
+                    errorText || res.statusText, res.status);
+                }
+                return res.json();
+            }
+            catch (error) {
+                if (error instanceof FailedRequestError) {
+                    throw error; // rethrow FailedRequestError
+                }
+                // Handle CanceledError specifically
+                if (error.message.includes('The operation was aborted')) {
+                    throw new CanceledError();
+                }
+                // Log the error and throw a FailedRequestError
+                this.logger.error('Error posting data', { endpoint, error });
+                throw new FailedRequestError(error instanceof Error ? error.message : 'Unknown error', error.response?.status);
+            }
+        }
         // Buffer and Readable → keep Axios (streams work fine there)
         if (!(data instanceof ReadableStream)) {
             if (data instanceof Readable) {
@@ -137,3 +177,79 @@ async function toFetchBody(data) {
     const blob = await new Response(data).blob();
     return { body: blob }; // browser sets length
 }
+const isNode = typeof process !== 'undefined' && !!process.versions?.node;
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+function isFirefoxOrSafari() {
+    if (!isBrowser)
+        return false;
+    const ua = navigator.userAgent;
+    return ua.includes('Firefox') || ua.includes('Safari');
+}
+/** Create a re-usable body for x402 fetch protocol */
+export async function toX402FetchBody(data) {
+    //
+    // 🔹 NODE: always buffer to a non-stream body (Buffer)
+    //         so fetchWithPayment can reuse it safely.
+    //
+    if (isNode) {
+        let buf;
+        // Web ReadableStream → Buffer
+        if (typeof ReadableStream !== 'undefined' &&
+            data instanceof ReadableStream) {
+            const ab = await new Response(data).arrayBuffer();
+            buf = Buffer.from(ab);
+        }
+        // Node Readable → Buffer
+        else if (data instanceof Readable) {
+            const chunks = [];
+            for await (const chunk of data) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            buf = Buffer.concat(chunks.map((c) => Uint8Array.from(c)));
+        }
+        // Buffer / Uint8Array
+        else if (Buffer.isBuffer(data)) {
+            buf = data;
+        }
+        else if (data instanceof Uint8Array) {
+            buf = Buffer.from(data);
+        }
+        else {
+            throw new Error('Unsupported body type for toFetchBody (Node)');
+        }
+        // For Buffer body, Node *does not* need duplex.
+        return { body: buf };
+    }
+    //
+    // 🔹 BROWSER: keep your previous behavior (streams/Blob), no duplex.
+    //
+    let body;
+    // Already a web ReadableStream
+    if (typeof ReadableStream !== 'undefined' && data instanceof ReadableStream) {
+        body = data;
+    }
+    // Node Readable in browser (rare, but be safe) → Blob
+    else if (data instanceof Readable) {
+        const chunks = [];
+        for await (const chunk of data) {
+            const buf = typeof chunk === 'string'
+                ? new TextEncoder().encode(chunk)
+                : new Uint8Array(chunk);
+            chunks.push(buf);
+        }
+        body = new Blob(chunks);
+    }
+    // Buffer / Uint8Array
+    else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        body = new Blob([Uint8Array.from(data)]);
+    }
+    else {
+        throw new Error('Unsupported body type for toFetchBody (browser)');
+    }
+    // Firefox / Safari – avoid streaming uploads
+    if (isFirefoxOrSafari() && body instanceof ReadableStream) {
+        const blob = await new Response(body).blob();
+        return { body: blob };
+    }
+    return { body };
+}

package/lib/esm/common/signer.js

@@ -25,6 +25,9 @@ import { randomBytes } from 'crypto';
 import { Wallet as EthereumWallet, ethers, parseEther } from 'ethers';
 import { computeAddress } from 'ethers';
 import nacl from 'tweetnacl';
+import { createWalletClient, custom, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { baseSepolia } from 'viem/chains';
 import { isEthereumWalletAdapter, isSolanaWalletAdapter, } from '../types.js';
 import { fromB64Url, ownerToAddress as ownerToB64Address, toB64Url, } from '../utils/base64.js';
 import { TurboWinstonLogger } from './logger.js';
@@ -148,3 +151,34 @@ export class TurboDataItemAbstractSigner {
         return this.signer.sign(dataToSign);
     }
 }
+export async function makeX402Signer(arbundlesSigner) {
+    // Node: our SDK uses EthereumSigner with a raw private key
+    if (arbundlesSigner instanceof EthereumSigner) {
+        return createWalletClient({
+            account: privateKeyToAccount(('0x' +
+                Buffer.from(arbundlesSigner.key).toString('hex'))),
+            chain: baseSepolia,
+            transport: http(),
+        });
+    }
+    // Browser: use injected wallet + selected account
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof window !== 'undefined' && window.ethereum) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const provider = window.ethereum;
+        // ask wallet for an account
+        const accounts = (await provider.request({
+            method: 'eth_requestAccounts',
+        }));
+        if (accounts === undefined || accounts.length === 0) {
+            throw new Error('No accounts returned from wallet');
+        }
+        const account = accounts[0];
+        return createWalletClient({
+            account,
+            chain: baseSepolia,
+            transport: custom(provider),
+        });
+    }
+    throw new Error('Unable to construct x402 signer for x402 options');
+}