@ardrive/turbo-sdk 1.0.0-alpha.20 → 1.0.0-alpha.22

package/README.md

@@ -1,12 +1,11 @@
 # @ardriveapp/turbo-sdk 🚀
 
-Welcome to the `@ardrive/turbo-sdk`! This SDK provides functionalities for interacting with the Turbo Upload and Payment Services. It is available in both NodeJS and Web environments.
+Welcome to the `@ardrive/turbo-sdk`! This SDK provides functionality for interacting with the Turbo Upload and Payment Services and is available for both NodeJS and Web environments.
 
 ## Table of Contents
 
 - [Installation](#installation)
-- [Usage](#usage):
-
+- [Usage](#usage)
   - [NodeJS Environments](#nodejs)
     - [CommonJS](#commonjs)
     - [ESM](#esm)
@@ -15,7 +14,6 @@ Welcome to the `@ardrive/turbo-sdk`! This SDK provides functionalities for inter
     - [Browser](#browser)
   - [Typescript](#typescript)
   - [Examples](./examples)
-
 - [Contributions](#contributions)
 
 ## Installation
@@ -32,14 +30,14 @@ yarn add @ardrive/turbo-sdk
 
 ## Usage
 
-The SDK is available in both CommonJS and ESM formats and is compatible with bundlers such as Webpack, Rollup, and ESbuild.
+The SDK is provided in both CommonJS and ESM formats, and it's compatible with bundlers such as Webpack, Rollup, and ESbuild. Utilize the appropriate named exports provided by this SDK's [package.json] based on your project's configuration. Refer to the [examples] directory to see how to use the SDK in various environments.
 
 ### Web
 
 #### Bundlers (Webpack, Rollup, ESbuild, etc.)
 
 ```javascript
-import { TurboFactory } from '@ardrive/turbo-sdk/web';
+import { TurboFactory } from '@ardrive/turbo-sdk';
 
 const turbo = TurboFactory.unauthenticated({});
 const rates = await turbo.getFiatRates();
@@ -59,14 +57,58 @@ const rates = await turbo.getFiatRates();
 
 #### CommonJS
 
+Project's `package.json`:
+
+```json
+{
+  "type": "commonjs" // or absent
+}
+```
+
+tsconfig's `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "skipLibCheck": true
+  }
+}
+```
+
+Usage:
+
 ```javascript
-const { TurboFactory } = require('@ardrive/turbo-sdk/node');
+const { TurboFactory } = require('@ardrive/turbo-sdk');
 
 const turbo = TurboFactory.unauthenticated({});
 const rates = await turbo.getFiatRates();
 ```
 
-### ESM
+#### ESM
+
+Project's `package.json`:
+
+```json
+{
+  "type": "module"
+}
+```
+
+tsconfig's `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "skipLibCheck": true
+  }
+}
+```
+
+Usage:
 
 ```javascript
 import { TurboFactory } from '@ardrive/turbo-sdk/node';
@@ -77,7 +119,7 @@ const rates = await turbo.getFiatRates();
 
 ### Typescript
 
-The SDK provides TypeScript typings. When you import the SDK in a TypeScript project:
+The SDK provides TypeScript types. When you import the SDK in a TypeScript project:
 
 ```typescript
 import Ardrive from '@ardrive/turbo-sdk/web';
@@ -85,30 +127,99 @@ import Ardrive from '@ardrive/turbo-sdk/web';
 // or '@ardrive/turbo-sdk/node' for Node.js projects
 ```
 
-The provided typings (`./lib/types/index.d.ts`) will be automatically recognized, offering type checking and autocompletion benefits.
+Types are exported from `./lib/types/index.d.ts` and should be automatically recognized, offering benefits such as type-checking and autocompletion.
 
-## APIs (WIP)
+## APIs
 
 ### TurboFactory
 
-- `public()`
-- `private()`
+- `unauthenticated()` - Creates an instance of a client that accesses Turbo's unauthenticated services.
+
+  ```typescript
+  const turbo = TurboFactory.unauthenticated({});
+  ```
+
+- `authenticated()` - Creates an instance of a client that accesses Turbo's authenticated and unauthenticated services.
+
+  ```typescript
+  const jwk = await arweave.crypto.generateJWK();
+  const turbo = TurboFactory.authenticated({ privateKey: jwk });
+  ```
 
 ### TurboUnauthenticatedClient
 
-- `getFiatRates()`
-- `getFiatToAR()`
-- `getSupportedCountries()`
-- `getSupportedCurrencies()`
-- `getWincForFiat()`
-- `getUploadCosts()`
-- `uploadSignedDataItem()`
+- `getSupportedCurrencies()` - Returns the list of currencies supported by the Turbo Payment Service for topping up a user balance of AR Credits (measured in Winston Credits, or winc).
+
+  ```typescript
+  const currencies = await turbo.getSupportedCurrencies();
+  ```
+
+- `getSupportedCountries()` - Returns the list of countries supported by the Turbo Payment Service's top up workflow.
+
+  ```typescript
+  const countries = await turbo.getSupportedCountries();
+  ```
+
+- `getFiatToAR()` - Returns the current raw fiat to AR conversion rate for a specific currency as reported by third-party pricing oracles.
+
+  ```typescript
+  const fiatToAR = await turbo.getFiatToAR({ currency: 'USD' });
+  ```
+
+- `getFiatRates()` - Returns the current fiat rates for 1 GiB of data for supported currencies, including all top-up adjustments and fees.
+
+  ```typescript
+  const rates = await turbo.getFiatRates();
+  ```
+
+- `getWincForFiat({ amount, currency })` - Returns the current conversion rate for Winston Credits for the provided fiat currency and amount, including all top-up adjustments and fees.
+
+  ```typescript
+  const winc = await turbo.getWincForFiat({ amount: 100, currency: 'USD' });
+  ```
+
+- `getUploadCosts({ bytes })` - Returns the estimated cost in Winston Credits for the provided file sizes, including all upload adjustments and fees.
+
+  ```typescript
+  const costs = await turbo.getUploadCosts({ bytes: [1000, 2000] });
+  ```
+
+- `uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal })` - Uploads a signed data item. The provided dataItemStreamFactory should produce a NEW signed data item stream each time is it invoked. The `dataItemSizeFactory` is a function that returns the size of the file.
+
+  ```typescript
+  const filePath = path.join(__dirname, './my-signed-data-item');
+  const dataItemSize = fs.statSync(filePath).size;
+  const uploadResponse = await turbo.uploadSignedDataItem({
+    dataItemStreamFactory: () => fs.createReadStream(filePath),
+    dataItemSizeFactory: () => dataItemSize,
+    signal: AbortSignal.timeout(10_000), // cancel the upload after 10 seconds
+  });
+  ```
 
 ### TurboAuthenticatedClient
 
-- `getBalance()`
-- `uploadFile()`
+- `getBalance()` - Issues a signed request to get the credit balance of a wallet measured in AR (measured in Winston Credits, or winc).
+
+  ```typescript
+  const balance = await turbo.getBalance();
+  ```
+
+- `uploadFile({ fileStreamFactory, fileSizeFactory, signal })` - Signs and uploads a raw file. The provided `fileStreamFactory` should produce a NEW file data stream each time is it invoked. The `fileSizeFactory` is a function that returns the size of the file.
+
+  ```typescript
+  const filePath = path.join(__dirname, './my-unsigned-file.txt');
+  const fileSize = fs.stateSync(filePath).size;
+  const uploadResult = await turboAuthClient.uploadFile({
+    fileStreamFactory: () => fs.createReadStream(filePath),
+    fileSizeFactory: () => fileSize,
+  });
+  ```
 
 ## Contributions
 
-If you encounter any issues or have feature requests, please file an issue on our GitHub repository. Contributions, pull requests, and feedback are welcome and encouraged.
+If you encounter any issues or have feature requests, please file an issue on our GitHub repository. Contributions, pull requests, and feedback are both welcome and encouraged.
+
+[package.json]: ./package.json
+[examples]: ./examples
+[TurboUnauthenticatedClient]: #turboUnauthenticatedClient
+[TurboAuthenticatedClient]: #turboAuthenticatedClient

package/bundles/web.bundle.min.js

@@ -47480,14 +47480,17 @@ var TurboUnauthenticatedUploadService = class {
   }
   async uploadSignedDataItem({
     dataItemStreamFactory,
+    dataItemSizeFactory,
     signal
   }) {
+    const fileSize = dataItemSizeFactory();
     return this.httpService.post({
       endpoint: `/tx`,
       signal,
       data: dataItemStreamFactory(),
       headers: {
-        "content-type": "application/octet-stream"
+        "content-type": "application/octet-stream",
+        "content-length": `${fileSize}`
       }
     });
   }
@@ -47503,17 +47506,22 @@ var TurboAuthenticatedUploadService = class extends TurboUnauthenticatedUploadSe
   }
   async uploadFile({
     fileStreamFactory,
+    fileSizeFactory,
     signal
   }) {
-    const signedDataItem = await this.signer.signDataItem({
-      fileStreamFactory
+    const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
+      fileStreamFactory,
+      fileSizeFactory
     });
+    const signedDataItem = dataItemStreamFactory();
+    const fileSize = dataItemSizeFactory();
     return this.httpService.post({
       endpoint: `/tx`,
       signal,
       data: signedDataItem,
       headers: {
-        "content-type": "application/octet-stream"
+        "content-type": "application/octet-stream",
+        "content-length": `${fileSize}`
       }
     });
   }
@@ -47579,10 +47587,12 @@ var TurboUnauthenticatedClient = class {
    */
   async uploadSignedDataItem({
     dataItemStreamFactory,
+    dataItemSizeFactory,
     signal
   }) {
     return this.uploadService.uploadSignedDataItem({
       dataItemStreamFactory,
+      dataItemSizeFactory,
       signal
     });
   }
@@ -47605,9 +47615,14 @@ var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
    */
   async uploadFile({
     fileStreamFactory,
+    fileSizeFactory,
     signal
   }) {
-    return this.uploadService.uploadFile({ fileStreamFactory, signal });
+    return this.uploadService.uploadFile({
+      fileStreamFactory,
+      fileSizeFactory,
+      signal
+    });
   }
 };
 
@@ -55555,19 +55570,22 @@ function toB64Url(buffer) {
 // src/utils/readableStream.ts
 init_shim();
 async function readableStreamToBuffer({
-  stream
+  stream,
+  size
 }) {
   const reader = stream.getReader();
-  const chunks = [];
+  const buffer = import_buffer.Buffer.alloc(size);
+  let offset = 0;
   let done = false;
   while (!done) {
     const { done: streamDone, value } = await reader.read();
     done = streamDone;
     if (!done) {
-      chunks.push(value);
+      buffer.set(value, offset);
+      offset += value.byteLength;
     }
   }
-  return import_buffer.Buffer.concat(chunks);
+  return buffer;
 }
 
 // src/web/signer.ts
@@ -55578,15 +55596,20 @@ var TurboWebArweaveSigner = class {
     this.signer = new ArweaveSigner(this.privateKey);
   }
   async signDataItem({
-    fileStreamFactory
+    fileStreamFactory,
+    fileSizeFactory
   }) {
     const buffer = await readableStreamToBuffer({
-      stream: fileStreamFactory()
-      // TODO: add payload size to get performance improvements
+      stream: fileStreamFactory(),
+      size: fileSizeFactory()
     });
-    const signedDataItem = createData(buffer, this.signer);
+    const signedDataItem = createData(buffer, this.signer, {});
     await signedDataItem.sign(this.signer);
-    return signedDataItem.getRaw();
+    return {
+      // while this returns a Buffer - it needs to match our return type for uploading
+      dataItemStreamFactory: () => signedDataItem.getRaw(),
+      dataItemSizeFactory: () => signedDataItem.getRaw().length
+    };
   }
   // NOTE: this might be better in a parent class or elsewhere - easy enough to leave in here now and does require specific environment version of crypto
   async generateSignedRequestHeaders() {

package/lib/cjs/common/factory.js

@@ -6,8 +6,12 @@ const turbo_js_1 = require("./turbo.js");
 const upload_js_1 = require("./upload.js");
 class TurboBaseFactory {
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
-        const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService(Object.assign({}, paymentServiceConfig));
-        const uploadService = new upload_js_1.TurboUnauthenticatedUploadService(Object.assign({}, uploadServiceConfig));
+        const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({
+            ...paymentServiceConfig,
+        });
+        const uploadService = new upload_js_1.TurboUnauthenticatedUploadService({
+            ...uploadServiceConfig,
+        });
         return new turbo_js_1.TurboUnauthenticatedClient({
             uploadService,
             paymentService,

package/lib/cjs/common/http.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboHTTPService = void 0;
 const axiosClient_js_1 = require("../utils/axiosClient.js");
@@ -21,29 +12,25 @@ class TurboHTTPService {
             retryConfig,
         });
     }
-    get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { status, statusText, data } = yield this.axios.get(endpoint, {
-                headers,
-                signal,
-            });
-            if (!allowedStatuses.includes(status)) {
-                throw new errors_js_1.FailedRequestError(status, statusText);
-            }
-            return data;
+    async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
+        const { status, statusText, data } = await this.axios.get(endpoint, {
+            headers,
+            signal,
         });
+        if (!allowedStatuses.includes(status)) {
+            throw new errors_js_1.FailedRequestError(status, statusText);
+        }
+        return data;
     }
-    post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { status, statusText, data: response, } = yield this.axios.post(endpoint, data, {
-                headers,
-                signal,
-            });
-            if (!allowedStatuses.includes(status)) {
-                throw new errors_js_1.FailedRequestError(status, statusText);
-            }
-            return response;
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
+        const { status, statusText, data: response, } = await this.axios.post(endpoint, data, {
+            headers,
+            signal,
         });
+        if (!allowedStatuses.includes(status)) {
+            throw new errors_js_1.FailedRequestError(status, statusText);
+        }
+        return response;
     }
 }
 exports.TurboHTTPService = TurboHTTPService;

package/lib/cjs/common/payment.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = void 0;
 const http_js_1 = require("./http.js");
@@ -18,48 +9,36 @@ class TurboUnauthenticatedPaymentService {
             retryConfig,
         });
     }
-    getFiatRates() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/rates',
-            });
+    async getFiatRates() {
+        return this.httpService.get({
+            endpoint: '/rates',
         });
     }
-    getFiatToAR({ currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: `/rates/${currency}`,
-            });
+    async getFiatToAR({ currency, }) {
+        return this.httpService.get({
+            endpoint: `/rates/${currency}`,
         });
     }
-    getSupportedCountries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/countries',
-            });
+    async getSupportedCountries() {
+        return this.httpService.get({
+            endpoint: '/countries',
         });
     }
-    getSupportedCurrencies() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/currencies',
-            });
+    async getSupportedCurrencies() {
+        return this.httpService.get({
+            endpoint: '/currencies',
         });
     }
-    getUploadCosts({ bytes, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fetchPricePromises = bytes.map((byteCount) => this.httpService.get({
-                endpoint: `/price/bytes/${byteCount}`,
-            }));
-            const wincCostsForBytes = yield Promise.all(fetchPricePromises);
-            return wincCostsForBytes;
-        });
+    async getUploadCosts({ bytes, }) {
+        const fetchPricePromises = bytes.map((byteCount) => this.httpService.get({
+            endpoint: `/price/bytes/${byteCount}`,
+        }));
+        const wincCostsForBytes = await Promise.all(fetchPricePromises);
+        return wincCostsForBytes;
     }
-    getWincForFiat({ amount, currency }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: `/price/${currency}/${amount}`,
-            });
+    async getWincForFiat({ amount, currency }) {
+        return this.httpService.get({
+            endpoint: `/price/${currency}/${amount}`,
         });
     }
 }
@@ -70,17 +49,15 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
         super({ url, retryConfig });
         this.signer = signer;
     }
-    getBalance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const headers = yield this.signer.generateSignedRequestHeaders();
-            const balance = yield this.httpService.get({
-                endpoint: '/balance',
-                headers,
-                allowedStatuses: [200, 404],
-            });
-            // 404's don't return a balance, so default to 0
-            return balance.winc ? balance : { winc: '0' };
+    async getBalance() {
+        const headers = await this.signer.generateSignedRequestHeaders();
+        const balance = await this.httpService.get({
+            endpoint: '/balance',
+            headers,
+            allowedStatuses: [200, 404],
         });
+        // 404's don't return a balance, so default to 0
+        return balance.winc ? balance : { winc: '0' };
     }
 }
 exports.TurboAuthenticatedPaymentService = TurboAuthenticatedPaymentService;

package/lib/cjs/common/turbo.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedClient = exports.TurboUnauthenticatedClient = void 0;
 const payment_js_1 = require("./payment.js");
@@ -20,10 +11,8 @@ class TurboUnauthenticatedClient {
     /**
      * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
      */
-    getFiatToAR({ currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getFiatToAR({ currency });
-        });
+    async getFiatToAR({ currency, }) {
+        return this.paymentService.getFiatToAR({ currency });
     }
     /**
      * Returns the latest conversion rates to purchase 1GiB of data for all supported currencies, including all adjustments and fees.
@@ -31,52 +20,41 @@ class TurboUnauthenticatedClient {
      * Note: this does not take into account varying adjustments and promotions for different sizes of data. If you want to calculate the total
      * cost in 'winc' for a given number of bytes, use getUploadCosts.
      */
-    getFiatRates() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getFiatRates();
-        });
+    async getFiatRates() {
+        return this.paymentService.getFiatRates();
     }
     /**
      * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
      */
-    getSupportedCountries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getSupportedCountries();
-        });
+    async getSupportedCountries() {
+        return this.paymentService.getSupportedCountries();
     }
     /**
      * Returns a list of all supported fiat currencies.
      */
-    getSupportedCurrencies() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getSupportedCurrencies();
-        });
+    async getSupportedCurrencies() {
+        return this.paymentService.getSupportedCurrencies();
     }
     /**
      * Determines the price in 'winc' to upload one data item of a specific size in bytes, including all Turbo cost adjustments and fees.
      */
-    getUploadCosts({ bytes, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getUploadCosts({ bytes });
-        });
+    async getUploadCosts({ bytes, }) {
+        return this.paymentService.getUploadCosts({ bytes });
     }
     /**
      * Determines the amount of 'winc' that would be returned for a given currency and amount, including all Turbo cost adjustments and fees.
      */
-    getWincForFiat({ amount, currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getWincForFiat({ amount, currency });
-        });
+    async getWincForFiat({ amount, currency, }) {
+        return this.paymentService.getWincForFiat({ amount, currency });
     }
     /**
      * Uploads a signed data item to the Turbo Upload Service.
      */
-    uploadSignedDataItem({ dataItemStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.uploadService.uploadSignedDataItem({
-                dataItemStreamFactory,
-                signal,
-            });
+    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
+        return this.uploadService.uploadSignedDataItem({
+            dataItemStreamFactory,
+            dataItemSizeFactory,
+            signal,
         });
     }
 }
@@ -88,17 +66,17 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     /**
      * Returns the current balance of the user's wallet in 'winc'.
      */
-    getBalance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getBalance();
-        });
+    async getBalance() {
+        return this.paymentService.getBalance();
     }
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    uploadFile({ fileStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.uploadService.uploadFile({ fileStreamFactory, signal });
+    async uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        return this.uploadService.uploadFile({
+            fileStreamFactory,
+            fileSizeFactory,
+            signal,
         });
     }
 }