@ardrive/turbo-sdk 1.31.0-alpha.1 → 1.31.0-alpha.3

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

@@ -21,7 +21,7 @@ const utils_js_1 = require("../utils.js");
 async function uploadFolder(options) {
     const turbo = await (0, utils_js_1.turboFromOptions)(options);
     const paidBy = await (0, utils_js_1.paidByFromOptions)(options, turbo);
-    const { disableManifest, fallbackFile, folderPath, indexFile, maxConcurrentUploads, chunkByteCount, chunkingMode, maxChunkConcurrency, } = (0, utils_js_1.getUploadFolderOptions)(options);
+    const { disableManifest, fallbackFile, folderPath, indexFile, maxConcurrentUploads, chunkByteCount, chunkingMode, maxChunkConcurrency, maxFinalizeMs, } = (0, utils_js_1.getUploadFolderOptions)(options);
     const customTags = (0, utils_js_1.getTagsFromOptions)(options);
     const result = await turbo.uploadFolder({
         folderPath: folderPath,
@@ -35,6 +35,7 @@ async function uploadFolder(options) {
         chunkByteCount,
         chunkingMode,
         maxChunkConcurrency,
+        maxFinalizeMs,
     });
     console.log('Uploaded folder:', JSON.stringify(result, null, 2));
 }

package/lib/cjs/cli/options.js

@@ -163,6 +163,10 @@ exports.optionMap = {
         alias: '--max-chunk-concurrency <maxChunkConcurrency>',
         description: 'Maximum number of concurrent chunks to upload per file',
     },
+    maxFinalizeMs: {
+        alias: '--max-finalize-ms <maxFinalizeMs>',
+        description: 'Maximum time in milliseconds to wait for the finalization of all chunks after the last chunk is uploaded. Defaults to 1 minute per GiB of the total file size.',
+    },
     chunkByteCount: {
         alias: '--chunk-byte-count <chunkByteCount>',
         description: 'Size of each chunk in bytes',
@@ -196,6 +200,7 @@ exports.uploadOptions = [
     exports.optionMap.useSignerBalanceFirst,
     exports.optionMap.tags,
     exports.optionMap.maxChunkConcurrency,
+    exports.optionMap.maxFinalizeMs,
     exports.optionMap.chunkByteCount,
     exports.optionMap.chunkingMode,
 ];

package/lib/cjs/cli/utils.js

@@ -294,5 +294,6 @@ function getChunkingOptions(options) {
         maxChunkConcurrency: options.maxChunkConcurrency !== undefined
             ? +options.maxChunkConcurrency
             : undefined,
+        maxFinalizeMs: options.maxFinalizeMs !== undefined ? +options.maxFinalizeMs : undefined,
     };
 }

package/lib/cjs/common/chunked.js

@@ -22,11 +22,15 @@ exports.splitReadableStreamIntoChunks = splitReadableStreamIntoChunks;
 const axios_1 = require("axios");
 const plimit_lit_1 = require("plimit-lit");
 const types_js_1 = require("../types.js");
+const common_js_1 = require("../utils/common.js");
+const errors_js_1 = require("../utils/errors.js");
 const events_js_1 = require("./events.js");
 const logger_js_1 = require("./logger.js");
 const fiveMiB = 5 * 1024 * 1024; // 5 MiB
 const fiveHundredMiB = fiveMiB * 100; // 500 MiB
 exports.defaultMaxChunkConcurrency = 5;
+// Limit uploaders to protect server
+const absoluteMaxChunkConcurrency = 256;
 exports.maxChunkByteCount = fiveHundredMiB;
 exports.minChunkByteCount = fiveMiB;
 exports.defaultChunkByteCount = exports.minChunkByteCount;
@@ -37,17 +41,19 @@ const chunkingHeader = { 'x-chunking-version': '2' };
  * uploading them in parallel, and emitting progress/error events.
  */
 class ChunkedUploader {
-    constructor({ http, token, maxChunkConcurrency = exports.defaultMaxChunkConcurrency, chunkByteCount = exports.defaultChunkByteCount, logger = logger_js_1.TurboWinstonLogger.default, chunkingMode = 'auto', dataItemByteCount, }) {
-        this.chunkByteCount = chunkByteCount;
-        this.maxChunkConcurrency = maxChunkConcurrency;
-        this.http = http;
-        this.token = token;
-        this.logger = logger;
+    constructor({ http, token, maxChunkConcurrency = exports.defaultMaxChunkConcurrency, maxFinalizeMs, chunkByteCount = exports.defaultChunkByteCount, logger = logger_js_1.TurboWinstonLogger.default, chunkingMode = 'auto', dataItemByteCount, }) {
         this.assertChunkParams({
             chunkByteCount,
             chunkingMode,
             maxChunkConcurrency,
+            maxFinalizeMs,
         });
+        this.chunkByteCount = chunkByteCount;
+        this.maxChunkConcurrency = maxChunkConcurrency;
+        this.maxFinalizeMs = maxFinalizeMs;
+        this.http = http;
+        this.token = token;
+        this.logger = logger;
         this.shouldUseChunkUploader = this.shouldChunkUpload({
             chunkByteCount,
             chunkingMode,
@@ -65,11 +71,18 @@ class ChunkedUploader {
         const isMoreThanTwoChunksOfData = dataItemByteCount > chunkByteCount * 2;
         return isMoreThanTwoChunksOfData;
     }
-    assertChunkParams({ chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
+    assertChunkParams({ chunkByteCount, chunkingMode, maxChunkConcurrency, maxFinalizeMs, }) {
+        if (maxFinalizeMs !== undefined &&
+            (Number.isNaN(maxFinalizeMs) ||
+                !Number.isInteger(maxFinalizeMs) ||
+                maxFinalizeMs < 0)) {
+            throw new Error('Invalid max finalization wait time. Must be a non-negative integer.');
+        }
         if (Number.isNaN(maxChunkConcurrency) ||
             !Number.isInteger(maxChunkConcurrency) ||
-            maxChunkConcurrency < 1) {
-            throw new Error('Invalid max chunk concurrency. Must be an integer of at least 1.');
+            maxChunkConcurrency < 1 ||
+            maxChunkConcurrency > absoluteMaxChunkConcurrency) {
+            throw new Error('Invalid max chunk concurrency. Must be an integer of at least 1 and at most 256.');
         }
         if (Number.isNaN(chunkByteCount) ||
             !Number.isInteger(chunkByteCount) ||
@@ -92,8 +105,8 @@ class ChunkedUploader {
         });
         if (res.chunkSize !== this.chunkByteCount) {
             this.logger.warn('Chunk size mismatch! Overriding with server value.', {
-                expected: this.chunkByteCount,
-                actual: res.chunkSize,
+                clientExpected: this.chunkByteCount,
+                serverReturned: res.chunkSize,
             });
             this.chunkByteCount = res.chunkSize;
         }
@@ -137,11 +150,6 @@ class ChunkedUploader {
             const chunkByteCount = chunk.length;
             const chunkOffset = currentOffset;
             currentOffset += chunkByteCount;
-            this.logger.debug('Queueing chunk', {
-                chunkPartNumber,
-                chunkOffset,
-                chunkByteCount,
-            });
             const promise = limit(async () => {
                 if (firstError !== undefined) {
                     return;
@@ -197,26 +205,79 @@ class ChunkedUploader {
         if (firstError !== undefined) {
             throw firstError;
         }
+        const finalizeResponse = await this.finalizeUpload(uploadId, dataItemByteCount, dataItemOpts?.paidBy, combinedSignal);
+        emitter.emit('upload-success');
+        return finalizeResponse;
+    }
+    toGiB(bytes) {
+        return bytes / 1024 ** 3;
+    }
+    async finalizeUpload(uploadId, dataItemByteCount, paidBy, signal) {
+        // Wait up to 1 minute per GiB of data for the upload to finalize
+        const fileSizeInGiB = Math.ceil(this.toGiB(dataItemByteCount));
+        const defaultMaxWaitTimeMins = fileSizeInGiB;
+        const maxWaitTimeMs = this.maxFinalizeMs ?? defaultMaxWaitTimeMins * 60 * 1000;
+        const minimumWaitPerStepMs = 
+        // Per step, files smaller than 100MB will wait 2 second,
+        dataItemByteCount < 1024 * 1024 * 100
+            ? 2000
+            : // files smaller than 3 GiB will wait 3 seconds,
+                dataItemByteCount < 1024 * 1024 * 1024 * 3
+                    ? 3000
+                    : // and larger files will wait 1 second per GiB with max of 10 seconds
+                        Math.max(1000 * fileSizeInGiB, 10000);
         const paidByHeader = {};
-        if (dataItemOpts?.paidBy !== undefined) {
-            paidByHeader['x-paid-by'] = Array.isArray(dataItemOpts.paidBy)
-                ? dataItemOpts.paidBy.join(',')
-                : dataItemOpts.paidBy;
+        if (paidBy !== undefined) {
+            paidByHeader['x-paid-by'] = Array.isArray(paidBy)
+                ? paidBy.join(',')
+                : paidBy;
         }
-        // TODO: Async Finalize
-        // Finalize and reconstruct server-side
-        const finalizeResponse = await this.http.post({
-            endpoint: `/chunks/${this.token}/${uploadId}/-1`,
+        await this.http.post({
+            endpoint: `/chunks/${this.token}/${uploadId}/finalize`,
             data: Buffer.alloc(0),
             headers: {
                 'Content-Type': 'application/octet-stream',
                 ...paidByHeader,
                 ...chunkingHeader,
             },
-            signal: combinedSignal,
+            signal,
         });
-        emitter.emit('upload-success');
-        return finalizeResponse;
+        this.logger.debug(`Confirming upload to Turbo with uploadId ${uploadId} for up to ${defaultMaxWaitTimeMins} minutes.`);
+        const startTime = Date.now();
+        const cutoffTime = startTime + maxWaitTimeMs;
+        let attempts = 0;
+        while (Date.now() < cutoffTime) {
+            // Wait for 3/4 of the time remaining per attempt or minimum step
+            const waitTimeMs = Math.min(Math.floor((cutoffTime - Date.now()) * (3 / 4)), minimumWaitPerStepMs);
+            await (0, common_js_1.sleep)(waitTimeMs);
+            if (signal?.aborted) {
+                this.logger.warn(`Upload finalization aborted by signal.`);
+                throw new axios_1.CanceledError();
+            }
+            const response = await this.http.get({
+                endpoint: `/chunks/${this.token}/${uploadId}/status`,
+                signal,
+            });
+            this.logger.debug(`Upload status found: ${response.status}`, {
+                status: response.status,
+                attempts: attempts++,
+                maxWaitTimeMs,
+                minimumWaitPerStepMs,
+                waitTimeMs,
+                elapsedMs: Date.now() - startTime,
+            });
+            if (response.status === 'FINALIZED') {
+                this.logger.debug(`Upload finalized successfully.`);
+                return response.receipt;
+            }
+            if (response.status === 'UNDERFUNDED') {
+                throw new errors_js_1.FailedRequestError(`Insufficient balance`, 402);
+            }
+            if (types_js_1.multipartFailedStatus.includes(response.status)) {
+                throw new errors_js_1.FailedRequestError(`Upload failed with multi-part status ${response.status}`);
+            }
+        }
+        throw new Error(`Upload multi-part finalization has timed out for Upload ID ${uploadId}`);
     }
 }
 exports.ChunkedUploader = ChunkedUploader;

package/lib/cjs/common/http.js

@@ -17,27 +17,34 @@ exports.TurboHTTPService = void 0;
  * limitations under the License.
  */
 const axios_1 = require("axios");
+const node_stream_1 = require("node:stream");
 const axiosClient_js_1 = require("../utils/axiosClient.js");
+const common_js_1 = require("../utils/common.js");
 const errors_js_1 = require("../utils/errors.js");
 class TurboHTTPService {
-    constructor({ url, retryConfig, logger, }) {
+    constructor({ url, logger, retryConfig = (0, axiosClient_js_1.defaultRetryConfig)(logger), }) {
         this.logger = logger;
         this.axios = (0, axiosClient_js_1.createAxiosInstance)({
             axiosConfig: {
                 baseURL: url,
                 maxRedirects: 0, // prevents backpressure issues when uploading larger streams via https
             },
-            retryConfig,
             logger: this.logger,
         });
+        this.retryConfig = retryConfig;
     }
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
-        return this.tryRequest(() => this.axios.get(endpoint, { headers, signal }), allowedStatuses);
+        return this.retryRequest(() => this.axios.get(endpoint, { headers, signal }), allowedStatuses);
     }
     async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
         // Buffer and Readable → keep Axios (streams work fine there)
         if (!(data instanceof ReadableStream)) {
-            return this.tryRequest(() => this.axios.post(endpoint, data, { headers, signal }), allowedStatuses);
+            if (data instanceof node_stream_1.Readable) {
+                return this.tryRequest(
+                // Can't retry a Readable stream that has already been partially consumed
+                () => this.axios.post(endpoint, data, { headers, signal }), allowedStatuses);
+            }
+            return this.retryRequest(() => this.axios.post(endpoint, data, { headers, signal }), allowedStatuses);
         }
         // Browser ReadableStream → use fetch with progressive enhancement of duplex
         // Note: fetch does not support streams in Safari and Firefox, so we convert to Blob
@@ -95,6 +102,34 @@ class TurboHTTPService {
             throw error;
         }
     }
+    async retryRequest(request, allowedStatuses) {
+        let attempt = 0;
+        let lastError;
+        while (attempt < this.retryConfig.retries) {
+            try {
+                const resp = await this.tryRequest(request, allowedStatuses);
+                return resp;
+            }
+            catch (error) {
+                if (error instanceof errors_js_1.FailedRequestError) {
+                    lastError = error;
+                    this.retryConfig.onRetry(attempt + 1, error);
+                    if (error.status !== undefined &&
+                        error.status >= 400 &&
+                        error.status < 500) {
+                        // If it's a client error, we can stop retrying
+                        throw error;
+                    }
+                    await (0, common_js_1.sleep)(this.retryConfig.retryDelay(attempt + 1));
+                    attempt++;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw new errors_js_1.FailedRequestError('Max retries reached - ' + lastError?.message, lastError?.status);
+    }
 }
 exports.TurboHTTPService = TurboHTTPService;
 async function toFetchBody(data) {

package/lib/cjs/common/payment.js

@@ -17,13 +17,14 @@ exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentSe
  * limitations under the License.
  */
 const bignumber_js_1 = require("bignumber.js");
+const axiosClient_js_1 = require("../utils/axiosClient.js");
 const http_js_1 = require("./http.js");
 const logger_js_1 = require("./logger.js");
 const index_js_1 = require("./token/index.js");
 exports.developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 exports.defaultPaymentServiceURL = 'https://payment.ardrive.io';
 class TurboUnauthenticatedPaymentService {
-    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, logger = logger_js_1.TurboWinstonLogger.default, token = 'arweave', }) {
+    constructor({ url = exports.defaultPaymentServiceURL, logger = logger_js_1.TurboWinstonLogger.default, retryConfig = (0, axiosClient_js_1.defaultRetryConfig)(logger), token = 'arweave', }) {
         this.logger = logger;
         this.httpService = new http_js_1.TurboHTTPService({
             url: `${url}/v1`,

package/lib/cjs/common/upload.js

@@ -192,6 +192,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                     logger: this.logger,
                     dataItemByteCount: dataItemSizeFactory(),
                     chunkingMode: params.chunkingMode,
+                    maxFinalizeMs: params.maxFinalizeMs,
                 });
                 if (chunkedUploader.shouldUseChunkUploader) {
                     const response = await chunkedUploader.upload({
@@ -234,13 +235,10 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                         resolve();
                     });
                 });
-                await Promise.race([
-                    (0, common_js_1.sleep)(retryDelay(retries, error)),
-                    abortEventPromise,
-                ]);
+                await Promise.race([(0, common_js_1.sleep)(retryDelay(retries)), abortEventPromise]);
             }
         }
-        const msg = `Failed to upload file after ${maxRetries + 1} attempts\n${lastError instanceof Error ? lastError.message : lastError}`;
+        const msg = `Failed to upload file after ${retries + 1} attempts\n${lastError instanceof Error ? lastError.message : lastError}`;
         // After all retries, throw the last error for catching
         if (lastError instanceof errors_js_1.FailedRequestError) {
             lastError.message = msg;
@@ -291,7 +289,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, } = params;
+        const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, maxChunkConcurrency, chunkByteCount, chunkingMode, maxFinalizeMs, } = params;
         const { disableManifest, indexFile, fallbackFile } = manifestOptions;
         const paths = {};
         const response = {
@@ -365,6 +363,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType },
             chunkByteCount,
             maxChunkConcurrency,
+            maxFinalizeMs,
             chunkingMode,
         });
         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.tokenTypes = exports.fiatCurrencyTypes = void 0;
+exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
 exports.isCurrency = isCurrency;
 exports.isKyvePrivateKey = isKyvePrivateKey;
 exports.isEthPrivateKey = isEthPrivateKey;
@@ -31,6 +31,18 @@ exports.tokenTypes = [
     'pol',
     'base-eth',
 ];
+exports.multipartPendingStatus = [
+    'ASSEMBLING',
+    'VALIDATING',
+    'FINALIZING',
+];
+exports.multipartFailedStatus = [
+    'UNDERFUNDED',
+    'INVALID',
+    'APPROVAL_FAILED',
+    'REVOKE_FAILED',
+];
+exports.multipartFinalizedStatus = ['FINALIZED'];
 const isNodeUploadFolderParams = (p) => p.folderPath !== undefined;
 exports.isNodeUploadFolderParams = isNodeUploadFolderParams;
 const isWebUploadFolderParams = (p) => p.files !== undefined;

package/lib/cjs/utils/axiosClient.js

@@ -1,27 +1,4 @@
 "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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -42,8 +19,7 @@ exports.createAxiosInstance = exports.defaultRetryConfig = exports.defaultReques
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const axios_1 = __importStar(require("axios"));
-const axios_retry_1 = __importDefault(require("axios-retry"));
+const axios_1 = __importDefault(require("axios"));
 const logger_js_1 = require("../common/logger.js");
 const version_js_1 = require("../version.js");
 exports.defaultRequestHeaders = {
@@ -51,19 +27,14 @@ exports.defaultRequestHeaders = {
     'x-turbo-source-identifier': 'turbo-sdk',
 };
 const defaultRetryConfig = (logger = logger_js_1.TurboWinstonLogger.default) => ({
-    retryDelay: axios_retry_1.default.exponentialDelay,
+    retryDelay: (retryCount) => Math.min(1000 * 2 ** (retryCount - 1), 30 * 1000), // exponential backoff up to 30s
     retries: 5,
-    retryCondition: (error) => {
-        return (!(error instanceof axios_1.CanceledError) &&
-            axios_retry_1.default.isIdempotentRequestError(error) &&
-            axios_retry_1.default.isNetworkError(error));
-    },
     onRetry: (retryCount, error) => {
         logger.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
     },
 });
 exports.defaultRetryConfig = defaultRetryConfig;
-const createAxiosInstance = ({ logger = logger_js_1.TurboWinstonLogger.default, axiosConfig = {}, retryConfig = (0, exports.defaultRetryConfig)(logger), } = {}) => {
+const createAxiosInstance = ({ axiosConfig = {}, } = {}) => {
     const axiosInstance = axios_1.default.create({
         ...axiosConfig,
         headers: {
@@ -73,11 +44,6 @@ const createAxiosInstance = ({ logger = logger_js_1.TurboWinstonLogger.default,
         adapter: 'fetch',
         validateStatus: () => true, // don't throw on non-200 status codes
     });
-    if (retryConfig.retries !== undefined && retryConfig.retries > 0) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        (0, axios_retry_1.default)(axiosInstance, retryConfig);
-    }
     return axiosInstance;
 };
 exports.createAxiosInstance = createAxiosInstance;

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.0-alpha.1';
+exports.version = '1.31.0-alpha.3';

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

@@ -18,7 +18,7 @@ import { getTagsFromOptions, getUploadFolderOptions, paidByFromOptions, turboFro
 export async function uploadFolder(options) {
     const turbo = await turboFromOptions(options);
     const paidBy = await paidByFromOptions(options, turbo);
-    const { disableManifest, fallbackFile, folderPath, indexFile, maxConcurrentUploads, chunkByteCount, chunkingMode, maxChunkConcurrency, } = getUploadFolderOptions(options);
+    const { disableManifest, fallbackFile, folderPath, indexFile, maxConcurrentUploads, chunkByteCount, chunkingMode, maxChunkConcurrency, maxFinalizeMs, } = getUploadFolderOptions(options);
     const customTags = getTagsFromOptions(options);
     const result = await turbo.uploadFolder({
         folderPath: folderPath,
@@ -32,6 +32,7 @@ export async function uploadFolder(options) {
         chunkByteCount,
         chunkingMode,
         maxChunkConcurrency,
+        maxFinalizeMs,
     });
     console.log('Uploaded folder:', JSON.stringify(result, null, 2));
 }

package/lib/esm/cli/options.js

@@ -160,6 +160,10 @@ export const optionMap = {
         alias: '--max-chunk-concurrency <maxChunkConcurrency>',
         description: 'Maximum number of concurrent chunks to upload per file',
     },
+    maxFinalizeMs: {
+        alias: '--max-finalize-ms <maxFinalizeMs>',
+        description: 'Maximum time in milliseconds to wait for the finalization of all chunks after the last chunk is uploaded. Defaults to 1 minute per GiB of the total file size.',
+    },
     chunkByteCount: {
         alias: '--chunk-byte-count <chunkByteCount>',
         description: 'Size of each chunk in bytes',
@@ -193,6 +197,7 @@ export const uploadOptions = [
     optionMap.useSignerBalanceFirst,
     optionMap.tags,
     optionMap.maxChunkConcurrency,
+    optionMap.maxFinalizeMs,
     optionMap.chunkByteCount,
     optionMap.chunkingMode,
 ];

package/lib/esm/cli/utils.js

@@ -271,5 +271,6 @@ export function getChunkingOptions(options) {
         maxChunkConcurrency: options.maxChunkConcurrency !== undefined
             ? +options.maxChunkConcurrency
             : undefined,
+        maxFinalizeMs: options.maxFinalizeMs !== undefined ? +options.maxFinalizeMs : undefined,
     };
 }