@ardrive/turbo-sdk 1.31.1 → 1.32.0

package/lib/cjs/cli/commands/uploadFile.js

@@ -33,6 +33,7 @@ async function uploadFile(options) {
         fileSizeFactory: () => fileSize,
         dataItemOpts: { tags: [...constants_js_1.turboCliTags, ...customTags], paidBy },
         ...(0, utils_js_1.getChunkingOptions)(options),
+        ...(0, utils_js_1.onDemandOptionsFromOptions)(options),
     });
     console.log('Uploaded file:', JSON.stringify(result, null, 2));
 }

package/lib/cjs/cli/commands/uploadFolder.js

@@ -36,6 +36,7 @@ async function uploadFolder(options) {
         chunkingMode,
         maxChunkConcurrency,
         maxFinalizeMs,
+        ...(0, utils_js_1.onDemandOptionsFromOptions)(options),
     });
     console.log('Uploaded folder:', JSON.stringify(result, null, 2));
 }

package/lib/cjs/cli/options.js

@@ -176,6 +176,19 @@ exports.optionMap = {
         description: 'Chunking mode to use for the upload. Can be "auto", "force" or "disabled". Defaults to "auto".',
         default: 'auto',
     },
+    onDemand: {
+        alias: '--on-demand',
+        description: 'Enable on-demand crypto top-ups during upload if balance is insufficient',
+        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).',
+    },
+    maxCryptoTopUpValue: {
+        alias: '--max-crypto-top-up-value <maxCryptoTopUpValue>',
+        description: 'Maximum crypto top-up value to use for the upload. Defaults to no limit.',
+    },
 };
 exports.walletOptions = [
     exports.optionMap.walletFile,
@@ -193,6 +206,11 @@ exports.globalOptions = [
     exports.optionMap.paymentUrl,
     exports.optionMap.uploadUrl,
 ];
+const onDemandOptions = [
+    exports.optionMap.onDemand,
+    exports.optionMap.topUpBufferMultiplier,
+    exports.optionMap.maxCryptoTopUpValue,
+];
 exports.uploadOptions = [
     ...exports.walletOptions,
     exports.optionMap.paidBy,
@@ -203,6 +221,7 @@ exports.uploadOptions = [
     exports.optionMap.maxFinalizeMs,
     exports.optionMap.chunkByteCount,
     exports.optionMap.chunkingMode,
+    ...onDemandOptions,
 ];
 exports.uploadFolderOptions = [
     ...exports.uploadOptions,

package/lib/cjs/cli/utils.js

@@ -18,6 +18,7 @@ exports.paidByFromOptions = paidByFromOptions;
 exports.getUploadFolderOptions = getUploadFolderOptions;
 exports.parseTags = parseTags;
 exports.getTagsFromOptions = getTagsFromOptions;
+exports.onDemandOptionsFromOptions = onDemandOptionsFromOptions;
 exports.currencyFromOptions = currencyFromOptions;
 exports.requiredByteCountFromOptions = requiredByteCountFromOptions;
 exports.getChunkingOptions = getChunkingOptions;
@@ -268,6 +269,30 @@ function parseTags(tagsArr) {
 function getTagsFromOptions(options) {
     return parseTags(options.tags);
 }
+function onDemandOptionsFromOptions(options) {
+    if (!options.onDemand) {
+        return { fundingMode: new index_js_1.ExistingBalanceFunding() };
+    }
+    const value = options.maxCryptoTopUpValue;
+    let maxTokenAmount = undefined;
+    if (value !== undefined) {
+        if (isNaN(+value) || +value <= 0) {
+            throw new Error('maxTokenAmount must be a positive number');
+        }
+        const token = tokenFromOptions(options);
+        maxTokenAmount = index_js_1.tokenToBaseMap[token](value).toString();
+    }
+    if (options.topUpBufferMultiplier !== undefined &&
+        (isNaN(options.topUpBufferMultiplier) || options.topUpBufferMultiplier < 1)) {
+        throw new Error('topUpBufferMultiplier must be a number >= 1');
+    }
+    return {
+        fundingMode: new index_js_1.OnDemandFunding({
+            maxTokenAmount,
+            topUpBufferMultiplier: options.topUpBufferMultiplier,
+        }),
+    };
+}
 function currencyFromOptions(options) {
     const currency = options.currency?.toLowerCase();
     if (!(0, index_js_1.isCurrency)(currency)) {

package/lib/cjs/common/factory.js

@@ -109,6 +109,7 @@ class TurboBaseFactory {
             signer: turboSigner,
             logger,
             token,
+            paymentService,
         });
         return new turbo_js_1.TurboAuthenticatedClient({
             uploadService,

package/lib/cjs/common/payment.js

@@ -291,7 +291,7 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
         const txId = fundTx.id;
         try {
             // Let transaction settle some time
-            await this.tokenTools.pollForTxBeingAvailable({ txId });
+            await this.tokenTools.pollTxAvailability({ txId });
         }
         catch (e) {
             this.logger.error(`Failed to poll for transaction being available from ${this.token} gateway... Attempting to submit fund tx to Turbo...`, e);

package/lib/cjs/common/token/ario.js

@@ -66,7 +66,7 @@ class ARIOToken {
         });
         return { id: txId, target, reward: '0' };
     }
-    async pollForTxBeingAvailable() {
+    async pollTxAvailability() {
         // AO finality should be instant -- but we'll wait initial backoff to
         // provide infra some time to crank without reading the whole result
         return (0, common_js_1.sleep)(this.pollingOptions.initialBackoffMs);

package/lib/cjs/common/token/arweave.js

@@ -78,7 +78,7 @@ class ArweaveToken {
         await this.submitTx(tx);
         return { id, target, reward: tx.reward };
     }
-    async pollForTxBeingAvailable({ txId, }) {
+    async pollTxAvailability({ txId }) {
         const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
         this.logger.debug('Polling for transaction...', { txId });
         await (0, common_js_1.sleep)(initialBackoffMs);

package/lib/cjs/common/token/baseEth.js

@@ -5,7 +5,7 @@ const common_js_1 = require("../../utils/common.js");
 const ethereum_js_1 = require("./ethereum.js");
 class BaseEthToken extends ethereum_js_1.EthereumToken {
     constructor({ logger, gatewayUrl = common_js_1.defaultProdGatewayUrls['base-eth'], pollingOptions = {
-        initialBackoffMs: 1_000,
+        initialBackoffMs: 2_500,
         maxAttempts: 10,
         pollingIntervalMs: 2_500,
     }, } = {}) {
@@ -15,5 +15,21 @@ class BaseEthToken extends ethereum_js_1.EthereumToken {
             pollingOptions,
         });
     }
+    async getTxAvailability(txId) {
+        const tx = await this.rpcProvider.getTransactionReceipt(txId);
+        if (tx) {
+            const confirmations = await tx.confirmations();
+            if (confirmations >= 1) {
+                this.logger.debug('Transaction is available on chain', {
+                    txId,
+                    tx,
+                    confirmations,
+                });
+                return true;
+            }
+        }
+        this.logger.debug('Transaction not yet available on chain', { txId, tx });
+        return false;
+    }
 }
 exports.BaseEthToken = BaseEthToken;

package/lib/cjs/common/token/ethereum.js

@@ -48,13 +48,22 @@ class EthereumToken {
             target,
         };
     }
-    async pollForTxBeingAvailable({ txId, }) {
+    async getTxAvailability(txId) {
+        const tx = await this.rpcProvider.getTransaction(txId);
+        if (tx) {
+            this.logger.debug('Transaction is available on chain', { txId, tx });
+            return true;
+        }
+        this.logger.debug('Transaction not yet available on chain', { txId });
+        return false;
+    }
+    async pollTxAvailability({ txId }) {
         await new Promise((resolve) => setTimeout(resolve, this.pollingOptions.initialBackoffMs));
         let attempts = 0;
         while (attempts < this.pollingOptions.maxAttempts) {
             try {
-                const tx = await this.rpcProvider.getTransaction(txId);
-                if (tx) {
+                const txIsAvailable = await this.getTxAvailability(txId);
+                if (txIsAvailable) {
                     return;
                 }
             }
@@ -64,7 +73,7 @@ class EthereumToken {
             await new Promise((resolve) => setTimeout(resolve, this.pollingOptions.pollingIntervalMs));
             attempts++;
         }
-        throw new Error('Transaction not found after polling!');
+        throw new Error(`Transaction ${txId} not found after polling!`);
     }
 }
 exports.EthereumToken = EthereumToken;

package/lib/cjs/common/token/kyve.js

@@ -66,7 +66,7 @@ class KyveToken {
         });
         return { id: txHash, target };
     }
-    async pollForTxBeingAvailable({ txId, }) {
+    async pollTxAvailability({ txId }) {
         const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
         this.logger.debug('Polling for transaction...', {
             txId,

package/lib/cjs/common/token/solana.js

@@ -74,7 +74,7 @@ class SolanaToken {
             lastValidBlockHeight: tx.lastValidBlockHeight,
         }, 'finalized');
     }
-    async pollForTxBeingAvailable({ txId, }) {
+    async pollTxAvailability({ txId }) {
         const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
         this.logger.debug('Polling for transaction...', {
             txId,

package/lib/cjs/common/turbo.js

@@ -160,7 +160,7 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
+    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, maxFinalizeMs, fundingMode, }) {
         return this.uploadService.upload({
             data,
             dataItemOpts,
@@ -169,6 +169,8 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
             chunkByteCount,
             chunkingMode,
             maxChunkConcurrency,
+            fundingMode,
+            maxFinalizeMs,
         });
     }
     uploadFile(params) {

package/lib/cjs/common/upload.js

@@ -17,13 +17,16 @@ exports.TurboAuthenticatedBaseUploadService = exports.TurboUnauthenticatedUpload
  * limitations under the License.
  */
 const axios_1 = require("axios");
+const bignumber_js_1 = require("bignumber.js");
 const plimit_lit_1 = require("plimit-lit");
+const types_js_1 = require("../types.js");
 const axiosClient_js_1 = require("../utils/axiosClient.js");
 const common_js_1 = require("../utils/common.js");
 const errors_js_1 = require("../utils/errors.js");
 const chunked_js_1 = require("./chunked.js");
 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");
 function isTurboUploadFileWithStreamFactoryParams(params) {
     return 'fileStreamFactory' in params;
@@ -89,14 +92,16 @@ class TurboUnauthenticatedUploadService {
 exports.TurboUnauthenticatedUploadService = TurboUnauthenticatedUploadService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadService {
-    constructor({ url = exports.defaultUploadServiceURL, retryConfig, signer, logger, token, }) {
+    constructor({ url = exports.defaultUploadServiceURL, retryConfig, signer, logger, token, paymentService, }) {
         super({ url, retryConfig, logger, token });
+        this.enabledOnDemandTokens = ['ario', 'solana', 'base-eth'];
         this.signer = signer;
+        this.paymentService = paymentService;
     }
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
+    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, fundingMode, maxFinalizeMs, }) {
         // This function is intended to be usable in both Node and browser environments.
         if ((0, common_js_1.isBlob)(data)) {
             const streamFactory = () => data.stream();
@@ -107,6 +112,11 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                 signal,
                 dataItemOpts,
                 events,
+                chunkByteCount,
+                chunkingMode,
+                maxChunkConcurrency,
+                fundingMode,
+                maxFinalizeMs,
             });
         }
         const dataBuffer = (() => {
@@ -127,6 +137,8 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             chunkByteCount,
             chunkingMode,
             maxChunkConcurrency,
+            fundingMode,
+            maxFinalizeMs,
         });
     }
     resolveUploadFileConfig(params) {
@@ -158,7 +170,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         };
     }
     async uploadFile(params) {
-        const { signal, dataItemOpts, events, fileStreamFactory, fileSizeFactory } = this.resolveUploadFileConfig(params);
+        const { signal, dataItemOpts, events, fileStreamFactory, fileSizeFactory, fundingMode = new types_js_1.ExistingBalanceFunding(), } = this.resolveUploadFileConfig(params);
         let retries = 0;
         const maxRetries = this.retryConfig.retries ?? 3;
         const retryDelay = this.retryConfig.retryDelay ??
@@ -167,6 +179,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         let lastStatusCode = undefined; // Store the last status code for throwing
         const emitter = new events_js_1.TurboEventEmitter(events);
         // avoid duplicating signing on failures here - these errors will immediately be thrown
+        let cryptoFundResult;
         // TODO: move the retry implementation to the http class, and avoid awaiting here. This will standardize the retry logic across all upload methods.
         while (retries < maxRetries) {
             if (signal?.aborted) {
@@ -179,6 +192,14 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                 dataItemOpts,
                 emitter,
             });
+            if (fundingMode instanceof types_js_1.OnDemandFunding &&
+                cryptoFundResult === undefined) {
+                const totalByteCount = dataItemSizeFactory();
+                cryptoFundResult = await this.onDemand({
+                    totalByteCount,
+                    onDemandFunding: fundingMode,
+                });
+            }
             // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
             // which will create a new emitter with upload events. We await
             // this result due to the wrapped retry logic of this method.
@@ -202,7 +223,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                         signal,
                         events,
                     });
-                    return response;
+                    return { ...response, cryptoFundResult };
                 }
                 const response = await this.uploadSignedDataItem({
                     dataItemStreamFactory,
@@ -211,7 +232,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                     signal,
                     events,
                 });
-                return response;
+                return { ...response, cryptoFundResult };
             }
             catch (error) {
                 // Store the last encountered error and status for re-throwing after retries
@@ -289,7 +310,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
      */
     async uploadFolder(params) {
         this.logger.debug('Uploading folder...', { params });
-        const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, maxChunkConcurrency, chunkByteCount, chunkingMode, maxFinalizeMs, } = params;
+        const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, maxChunkConcurrency, chunkByteCount, chunkingMode, fundingMode = new types_js_1.ExistingBalanceFunding(), maxFinalizeMs, } = params;
         const { disableManifest, indexFile, fallbackFile } = manifestOptions;
         const paths = {};
         const response = {
@@ -331,6 +352,16 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         };
         const files = await this.getFiles(params);
         const limit = (0, plimit_lit_1.pLimit)(maxConcurrentUploads);
+        let cryptoFundResult;
+        if (fundingMode instanceof types_js_1.OnDemandFunding) {
+            const totalByteCount = files.reduce((acc, file) => {
+                return acc + this.getFileSize(file) + 1200; // allow extra per file for ANS-104 headers
+            }, 0);
+            cryptoFundResult = await this.onDemand({
+                totalByteCount,
+                onDemandFunding: fundingMode,
+            });
+        }
         await Promise.all(files.map((file) => limit(() => uploadFile(file))));
         this.logger.debug('Finished uploading files', {
             numFiles: files.length,
@@ -370,6 +401,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             ...response,
             manifest,
             manifestResponse,
+            cryptoFundResult,
         };
     }
     async shareCredits({ approvedAddress, approvedWincAmount, expiresBySeconds, }) {
@@ -424,5 +456,91 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         }
         return revokedApprovals;
     }
+    /**
+     * Triggers an upload that will top-up the wallet with Credits for the amount before uploading.
+     * First, it calculates the expected cost of the upload. Next, it checks the wallet for existing
+     * balance. If the balance is insufficient, it will attempt the top-up with the wallet in the specified `token`
+     * and await for the balance to be credited.
+     * Note: Only `ario`, `solana`, and `base-eth` tokens are currently supported for on-demand uploads.
+     */
+    async onDemand({ totalByteCount, onDemandFunding, }) {
+        const { maxTokenAmount, topUpBufferMultiplier } = onDemandFunding;
+        const currentBalance = await this.paymentService.getBalance();
+        const wincPriceForOneGiB = (await this.paymentService.getUploadCosts({
+            bytes: [2 ** 30],
+        }))[0].winc;
+        const expectedWincPrice = new bignumber_js_1.BigNumber(wincPriceForOneGiB)
+            .multipliedBy(totalByteCount)
+            .dividedBy(2 ** 30)
+            .toFixed(0, bignumber_js_1.BigNumber.ROUND_UP);
+        if ((0, bignumber_js_1.BigNumber)(currentBalance.effectiveBalance).isGreaterThanOrEqualTo(expectedWincPrice)) {
+            this.logger.debug('Sufficient balance for on demand upload', {
+                currentBalance,
+                expectedWincPrice,
+            });
+            return undefined;
+        }
+        this.logger.debug('Insufficient balance for on demand upload', {
+            currentBalance,
+            expectedWincPrice,
+        });
+        if (!this.enabledOnDemandTokens.includes(this.token)) {
+            throw new Error(`On-demand uploads are not supported for token: ${this.token}`);
+        }
+        const topUpWincAmount = (0, bignumber_js_1.BigNumber)(expectedWincPrice)
+            .minus(currentBalance.effectiveBalance)
+            .multipliedBy(topUpBufferMultiplier) // add buffer to avoid underpayment
+            .toFixed(0, bignumber_js_1.BigNumber.ROUND_UP);
+        const wincPriceForOneToken = (await this.paymentService.getWincForToken({
+            tokenAmount: index_js_1.tokenToBaseMap[this.token](1),
+        })).winc;
+        const topUpTokenAmount = new bignumber_js_1.BigNumber(topUpWincAmount)
+            .dividedBy(wincPriceForOneToken)
+            .multipliedBy(index_js_1.tokenToBaseMap[this.token](1))
+            .toFixed(0, bignumber_js_1.BigNumber.ROUND_UP);
+        if (maxTokenAmount !== undefined) {
+            if (new bignumber_js_1.BigNumber(topUpTokenAmount).isGreaterThan(maxTokenAmount)) {
+                throw new Error(`Top up token amount ${new bignumber_js_1.BigNumber(topUpTokenAmount).div(index_js_1.exponentMap[this.token])} is greater than the maximum allowed amount of ${maxTokenAmount}`);
+            }
+        }
+        this.logger.debug(`Topping up wallet with ${topUpTokenAmount} ${this.token} for ${topUpWincAmount} winc`);
+        const topUpResponse = await this.paymentService.topUpWithTokens({
+            tokenAmount: topUpTokenAmount,
+        });
+        this.logger.debug('Top up transaction submitted', { topUpResponse });
+        const pollingOptions = {
+            pollIntervalMs: 3 * 1000, // poll every 3 seconds
+            timeoutMs: 120 * 1000, // wait up to 2 minutes
+        };
+        let tries = 1;
+        const maxTries = Math.ceil(pollingOptions.timeoutMs / pollingOptions.pollIntervalMs) - 1; // -1 because we already tried once with the initial request
+        while (topUpResponse.status !== 'confirmed' && tries < maxTries) {
+            this.logger.debug('Tx not yet confirmed, waiting to poll again', {
+                tries,
+                maxTries,
+            });
+            await (0, common_js_1.sleep)(pollingOptions.pollIntervalMs);
+            tries++;
+            try {
+                const submitFundResult = await this.paymentService.submitFundTransaction({
+                    txId: topUpResponse.id,
+                });
+                if (submitFundResult.status === 'confirmed') {
+                    this.logger.debug('Top-up transaction confirmed and balance updated', { submitFundResult });
+                    topUpResponse.status = 'confirmed';
+                    break;
+                }
+            }
+            catch (error) {
+                this.logger.warn('Error fetching fund transaction during polling', {
+                    message: error instanceof Error ? error.message : error,
+                });
+            }
+        }
+        if (tries >= maxTries) {
+            this.logger.warn('Timed out waiting for fund tx to confirm after top-up. Will continue to attempt upload but it may fail if balance is insufficient.');
+        }
+        return topUpResponse;
+    }
 }
 exports.TurboAuthenticatedBaseUploadService = TurboAuthenticatedBaseUploadService;

package/lib/cjs/node/upload.js

@@ -23,13 +23,14 @@ const stream_1 = require("stream");
 const upload_js_1 = require("../common/upload.js");
 const types_js_1 = require("../types.js");
 class TurboAuthenticatedUploadService extends upload_js_1.TurboAuthenticatedBaseUploadService {
-    constructor({ url = upload_js_1.defaultUploadServiceURL, retryConfig, signer, logger, token, }) {
+    constructor({ url = upload_js_1.defaultUploadServiceURL, retryConfig, signer, logger, token, paymentService, }) {
         super({
             url,
             retryConfig,
             logger,
             token,
             signer,
+            paymentService,
         });
     }
     async getAbsoluteFilePathsFromFolder(folderPath) {

package/lib/cjs/types.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
+exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.OnDemandFunding = exports.ExistingBalanceFunding = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
 exports.isCurrency = isCurrency;
 exports.isKyvePrivateKey = isKyvePrivateKey;
 exports.isEthPrivateKey = isEthPrivateKey;
 exports.isSolanaWalletAdapter = isSolanaWalletAdapter;
 exports.isEthereumWalletAdapter = isEthereumWalletAdapter;
+const bignumber_js_1 = require("bignumber.js");
 exports.fiatCurrencyTypes = [
     'usd',
     'eur',
@@ -31,6 +32,24 @@ exports.tokenTypes = [
     'pol',
     'base-eth',
 ];
+class ExistingBalanceFunding {
+}
+exports.ExistingBalanceFunding = ExistingBalanceFunding;
+class OnDemandFunding {
+    constructor({ maxTokenAmount, topUpBufferMultiplier = 1.1, }) {
+        if (maxTokenAmount !== undefined &&
+            new bignumber_js_1.BigNumber(maxTokenAmount).isLessThan(0)) {
+            throw new Error('maxTokenAmount must be non-negative');
+        }
+        this.maxTokenAmount =
+            maxTokenAmount !== undefined ? new bignumber_js_1.BigNumber(maxTokenAmount) : undefined;
+        if (topUpBufferMultiplier < 1) {
+            throw new Error('topUpBufferMultiplier must be >= 1');
+        }
+        this.topUpBufferMultiplier = topUpBufferMultiplier;
+    }
+}
+exports.OnDemandFunding = OnDemandFunding;
 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.31.1';
+exports.version = '1.32.0';

package/lib/cjs/web/upload.js

@@ -19,8 +19,8 @@ exports.TurboAuthenticatedUploadService = void 0;
 const upload_js_1 = require("../common/upload.js");
 const types_js_1 = require("../types.js");
 class TurboAuthenticatedUploadService extends upload_js_1.TurboAuthenticatedBaseUploadService {
-    constructor({ url = upload_js_1.defaultUploadServiceURL, retryConfig, signer, logger, token, }) {
-        super({ url, retryConfig, logger, token, signer });
+    constructor({ url = upload_js_1.defaultUploadServiceURL, retryConfig, signer, logger, token, paymentService, }) {
+        super({ url, retryConfig, logger, token, signer, paymentService });
     }
     getFiles(params) {
         if (!(0, types_js_1.isWebUploadFolderParams)(params)) {

package/lib/esm/cli/commands/uploadFile.js

@@ -15,7 +15,7 @@
  */
 import { createReadStream, statSync } from 'fs';
 import { turboCliTags } from '../constants.js';
-import { getChunkingOptions, getTagsFromOptions, paidByFromOptions, turboFromOptions, } from '../utils.js';
+import { getChunkingOptions, getTagsFromOptions, onDemandOptionsFromOptions, paidByFromOptions, turboFromOptions, } from '../utils.js';
 export async function uploadFile(options) {
     const { filePath } = options;
     if (filePath === undefined) {
@@ -30,6 +30,7 @@ export async function uploadFile(options) {
         fileSizeFactory: () => fileSize,
         dataItemOpts: { tags: [...turboCliTags, ...customTags], paidBy },
         ...getChunkingOptions(options),
+        ...onDemandOptionsFromOptions(options),
     });
     console.log('Uploaded file:', JSON.stringify(result, null, 2));
 }

package/lib/esm/cli/commands/uploadFolder.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { turboCliTags } from '../constants.js';
-import { getTagsFromOptions, getUploadFolderOptions, paidByFromOptions, turboFromOptions, } from '../utils.js';
+import { getTagsFromOptions, getUploadFolderOptions, onDemandOptionsFromOptions, paidByFromOptions, turboFromOptions, } from '../utils.js';
 export async function uploadFolder(options) {
     const turbo = await turboFromOptions(options);
     const paidBy = await paidByFromOptions(options, turbo);
@@ -33,6 +33,7 @@ export async function uploadFolder(options) {
         chunkingMode,
         maxChunkConcurrency,
         maxFinalizeMs,
+        ...onDemandOptionsFromOptions(options),
     });
     console.log('Uploaded folder:', JSON.stringify(result, null, 2));
 }

package/lib/esm/cli/options.js

@@ -173,6 +173,19 @@ export const optionMap = {
         description: 'Chunking mode to use for the upload. Can be "auto", "force" or "disabled". Defaults to "auto".',
         default: 'auto',
     },
+    onDemand: {
+        alias: '--on-demand',
+        description: 'Enable on-demand crypto top-ups during upload if balance is insufficient',
+        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).',
+    },
+    maxCryptoTopUpValue: {
+        alias: '--max-crypto-top-up-value <maxCryptoTopUpValue>',
+        description: 'Maximum crypto top-up value to use for the upload. Defaults to no limit.',
+    },
 };
 export const walletOptions = [
     optionMap.walletFile,
@@ -190,6 +203,11 @@ export const globalOptions = [
     optionMap.paymentUrl,
     optionMap.uploadUrl,
 ];
+const onDemandOptions = [
+    optionMap.onDemand,
+    optionMap.topUpBufferMultiplier,
+    optionMap.maxCryptoTopUpValue,
+];
 export const uploadOptions = [
     ...walletOptions,
     optionMap.paidBy,
@@ -200,6 +218,7 @@ export const uploadOptions = [
     optionMap.maxFinalizeMs,
     optionMap.chunkByteCount,
     optionMap.chunkingMode,
+    ...onDemandOptions,
 ];
 export const uploadFolderOptions = [
     ...uploadOptions,