@ardrive/turbo-sdk 1.25.0 → 1.26.0

package/lib/cjs/common/upload.js

@@ -21,6 +21,7 @@ const plimit_lit_1 = require("plimit-lit");
 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 events_js_1 = require("./events.js");
 const http_js_1 = require("./http.js");
 const logger_js_1 = require("./logger.js");
 exports.creditSharingTagNames = {
@@ -42,19 +43,40 @@ class TurboUnauthenticatedUploadService {
         });
         this.retryConfig = retryConfig;
     }
-    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
+    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, dataItemOpts, signal, events = {}, }) {
         const fileSize = dataItemSizeFactory();
         this.logger.debug('Uploading signed data item...');
-        // TODO: add p-limit constraint or replace with separate upload class
-        return this.httpService.post({
+        // create the tapped stream with events
+        const emitter = new events_js_1.TurboEventEmitter(events);
+        // create the stream with upload events
+        const { stream: streamWithUploadEvents, resume } = (0, events_js_1.createStreamWithUploadEvents)({
+            data: dataItemStreamFactory(),
+            dataSize: fileSize,
+            emitter,
+        });
+        const headers = {
+            'content-type': 'application/octet-stream',
+            'content-length': `${fileSize}`,
+        };
+        if (dataItemOpts !== undefined && dataItemOpts.paidBy !== undefined) {
+            const paidBy = Array.isArray(dataItemOpts.paidBy)
+                ? dataItemOpts.paidBy
+                : [dataItemOpts.paidBy];
+            // TODO: these should be comma separated values vs. an array of headers
+            if (dataItemOpts.paidBy.length > 0) {
+                headers['x-paid-by'] = paidBy;
+            }
+        }
+        // setup the post request using the stream with upload events
+        const postPromise = this.httpService.post({
             endpoint: `/tx/${this.token}`,
             signal,
-            data: dataItemStreamFactory(),
-            headers: {
-                'content-type': 'application/octet-stream',
-                'content-length': `${fileSize}`,
-            },
+            data: streamWithUploadEvents,
+            headers,
         });
+        // resume the stream so events start flowing to the post
+        resume();
+        return postPromise;
     }
 }
 exports.TurboUnauthenticatedUploadService = TurboUnauthenticatedUploadService;
@@ -67,7 +89,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, }) {
+    upload({ data, dataItemOpts, signal, events, }) {
         // This function is intended to be usable in both Node and browser environments.
         if ((0, common_js_1.isBlob)(data)) {
             const streamFactory = () => data.stream();
@@ -77,6 +99,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
                 fileSizeFactory: sizeFactory,
                 signal,
                 dataItemOpts,
+                events,
             });
         }
         const dataBuffer = (() => {
@@ -93,56 +116,53 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             fileSizeFactory: () => dataBuffer.byteLength,
             signal,
             dataItemOpts,
+            events,
         });
     }
-    async uploadFile({ fileStreamFactory, fileSizeFactory, signal, dataItemOpts, }) {
+    async uploadFile({ fileStreamFactory, fileSizeFactory, signal, dataItemOpts, events = {}, }) {
         let retries = 0;
         const maxRetries = this.retryConfig.retries ?? 3;
         const retryDelay = this.retryConfig.retryDelay ??
             ((retryNumber) => retryNumber * 1000);
         let lastError = undefined; // Store the last error for throwing
         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
+        // TODO: create a SigningError class and throw that instead of the generic Error
+        const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
+            fileStreamFactory,
+            fileSizeFactory,
+            dataItemOpts,
+            emitter,
+        });
+        // 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) {
                 throw new axios_1.CanceledError();
             }
-            const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
-                fileStreamFactory,
-                fileSizeFactory,
-                dataItemOpts,
-            });
             try {
                 this.logger.debug('Uploading signed data item...');
-                // TODO: add p-limit constraint or replace with separate upload class
-                const headers = {
-                    'content-type': 'application/octet-stream',
-                    'content-length': `${dataItemSizeFactory()}`,
-                };
-                if (dataItemOpts !== undefined && dataItemOpts.paidBy !== undefined) {
-                    const paidBy = Array.isArray(dataItemOpts.paidBy)
-                        ? dataItemOpts.paidBy
-                        : [dataItemOpts.paidBy];
-                    if (dataItemOpts.paidBy.length > 0) {
-                        headers['x-paid-by'] = paidBy;
-                    }
-                }
-                const data = await this.httpService.post({
-                    endpoint: `/tx/${this.token}`,
+                // 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.
+                const response = await this.uploadSignedDataItem({
+                    dataItemStreamFactory,
+                    dataItemSizeFactory,
+                    dataItemOpts,
                     signal,
-                    data: dataItemStreamFactory(),
-                    headers,
+                    events,
                 });
-                return data;
+                return response;
             }
             catch (error) {
                 // Store the last encountered error and status for re-throwing after retries
                 lastError = error;
-                if (error instanceof axios_1.AxiosError) {
-                    lastStatusCode = error.response?.status;
-                }
-                else if (error instanceof errors_js_1.FailedRequestError) {
+                if (error instanceof errors_js_1.FailedRequestError) {
                     lastStatusCode = error.status;
                 }
+                else {
+                    lastStatusCode = error.response?.status;
+                }
                 if (lastStatusCode !== undefined &&
                     lastStatusCode >= 400 &&
                     lastStatusCode < 500) {
@@ -202,6 +222,14 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         }
         return this.contentTypeFromFile(file);
     }
+    /**
+     * TODO: add events to the uploadFolder method
+     * could be a predicate with a resolveConfig() function, eg: events: ({...file ctx}) => ({
+     *   onProgress: (progress) => {
+     *     console.log('progress', progress);
+     *   },
+     * })
+     */
     async uploadFolder(params) {
         this.logger.debug('Uploading folder...', { params });
         const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, } = params;

package/lib/cjs/node/signer.js

@@ -22,6 +22,7 @@ Object.defineProperty(exports, "ArweaveSigner", { enumerable: true, get: functio
 Object.defineProperty(exports, "EthereumSigner", { enumerable: true, get: function () { return arbundles_1.EthereumSigner; } });
 Object.defineProperty(exports, "HexSolanaSigner", { enumerable: true, get: function () { return arbundles_1.HexSolanaSigner; } });
 const stream_1 = require("stream");
+const events_js_1 = require("../common/events.js");
 const signer_js_1 = require("../common/signer.js");
 const base64_js_1 = require("../utils/base64.js");
 /**
@@ -31,23 +32,41 @@ class TurboNodeSigner extends signer_js_1.TurboDataItemAbstractSigner {
     constructor(p) {
         super(p);
     }
-    async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, emitter, }) {
         // TODO: replace with our own signer implementation
         this.logger.debug('Signing data item...');
+        // TODO: we could just use tee or PassThrough rather than require a fileStreamFactory
         let [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
         stream1 = stream1 instanceof Buffer ? stream_1.Readable.from(stream1) : stream1;
         stream2 = stream2 instanceof Buffer ? stream_1.Readable.from(stream2) : stream2;
-        const signedDataItem = await (0, arbundles_1.streamSigner)(stream1, stream2, this.signer, dataItemOpts);
-        this.logger.debug('Successfully signed data item...');
-        // TODO: support target, anchor, and tags
-        const signedDataItemSize = this.calculateSignedDataHeadersSize({
-            dataSize: fileSizeFactory(),
-            dataItemOpts,
+        // If we have a signing emitter, wrap the stream with events
+        const fileSize = fileSizeFactory();
+        const { stream: streamWithSigningEvents, resume } = (0, events_js_1.createStreamWithSigningEvents)({
+            data: stream1,
+            dataSize: fileSize,
+            emitter,
         });
-        return {
-            dataItemStreamFactory: () => signedDataItem,
-            dataItemSizeFactory: () => signedDataItemSize,
-        };
+        try {
+            const signedDataItemPromise = (0, arbundles_1.streamSigner)(streamWithSigningEvents, // TODO: use generics to avoid this cast
+            stream2, this.signer, dataItemOpts);
+            // resume the stream so bytes start flowing to the streamSigner
+            resume();
+            const signedDataItem = await signedDataItemPromise;
+            this.logger.debug('Successfully signed data item...');
+            const signedDataItemSize = this.calculateSignedDataHeadersSize({
+                dataSize: fileSizeFactory(),
+                dataItemOpts,
+            });
+            return {
+                dataItemStreamFactory: () => signedDataItem,
+                dataItemSizeFactory: () => signedDataItemSize,
+            };
+        }
+        catch (error) {
+            // TODO: create a SigningError class and throw that instead of the generic Error
+            emitter?.emit('signing-error', error);
+            throw error;
+        }
     }
     // TODO: make dynamic that accepts anchor and target and tags to return the size of the headers + data
     // reference https://github.com/ArweaveTeam/arweave-standards/blob/master/ans/ANS-104.md#13-dataitem-format

package/lib/cjs/node/upload.js

@@ -24,7 +24,13 @@ 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 });
+        super({
+            url,
+            retryConfig,
+            logger,
+            token,
+            signer,
+        });
     }
     async getAbsoluteFilePathsFromFolder(folderPath) {
         const absoluteFilePaths = [];

package/lib/cjs/utils/axiosClient.js

@@ -70,9 +70,12 @@ const createAxiosInstance = ({ logger = logger_js_1.TurboWinstonLogger.default,
             ...axiosConfig.headers,
             ...exports.defaultRequestHeaders,
         },
+        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;

package/lib/cjs/utils/readableStream.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readableStreamToBuffer = readableStreamToBuffer;
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 async function readableStreamToBuffer({ stream, size, }) {
     const reader = stream.getReader();
     const buffer = Buffer.alloc(size);

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.25.0';
+exports.version = '1.26.0';

package/lib/cjs/web/signer.js

@@ -42,38 +42,65 @@ class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
         await this.setPublicKey();
         return super.getPublicKey();
     }
-    async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, emitter, }) {
         await this.setPublicKey();
-        const fileStream = fileStreamFactory();
-        // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
-        const buffer = fileStream instanceof Buffer
-            ? fileStream
-            : await (0, readableStream_js_1.readableStreamToBuffer)({
-                stream: fileStream,
-                size: fileSizeFactory(),
+        // Create signing emitter if events are provided
+        const fileSize = fileSizeFactory();
+        try {
+            const fileStream = fileStreamFactory();
+            // start with 0 progress
+            emitter?.emit('signing-progress', {
+                processedBytes: 0,
+                totalBytes: fileSize,
             });
-        let signedDataItem;
-        this.logger.debug('Signing data item...');
-        if (this.signer instanceof arbundles_1.ArconnectSigner) {
-            this.logger.debug('Arconnect signer detected, signing with Arconnect signData Item API...');
-            const sign = Buffer.from(await this.signer['signer'].signDataItem({
-                data: Uint8Array.from(buffer),
-                tags: dataItemOpts?.tags,
-                target: dataItemOpts?.target,
-                anchor: dataItemOpts?.anchor,
-            }));
-            signedDataItem = new arbundles_1.DataItem(sign);
+            // TODO: implement streamReadableStreamSigner that incrementally signs the stream with events instead of converting to a buffer
+            const buffer = fileStream instanceof Buffer
+                ? fileStream
+                : await (0, readableStream_js_1.readableStreamToBuffer)({
+                    stream: fileStream,
+                    size: fileSize,
+                });
+            // TODO: replace this with streamSigner that uses a ReadableStream with events
+            emitter?.emit('signing-progress', {
+                processedBytes: Math.floor(fileSize / 2),
+                totalBytes: fileSize,
+            });
+            let signedDataItem;
+            this.logger.debug('Signing data item...');
+            if (this.signer instanceof arbundles_1.ArconnectSigner) {
+                this.logger.debug('Arconnect signer detected, signing with Arconnect signData Item API...');
+                const sign = Buffer.from(await this.signer['signer'].signDataItem({
+                    data: Uint8Array.from(buffer),
+                    tags: dataItemOpts?.tags,
+                    target: dataItemOpts?.target,
+                    anchor: dataItemOpts?.anchor,
+                }));
+                signedDataItem = new arbundles_1.DataItem(sign);
+            }
+            else {
+                signedDataItem = (0, arbundles_1.createData)(Uint8Array.from(buffer), this.signer, dataItemOpts);
+                await signedDataItem.sign(this.signer);
+            }
+            // emit last progress event (100%)
+            emitter?.emit('signing-progress', {
+                processedBytes: fileSize,
+                totalBytes: fileSize,
+            });
+            // emit completion event
+            emitter?.emit('signing-success');
+            this.logger.debug('Successfully signed data item...');
+            return {
+                // while this returns a Buffer - it needs to match our return type for uploading
+                dataItemStreamFactory: () => signedDataItem.getRaw(),
+                dataItemSizeFactory: () => signedDataItem.getRaw().length,
+            };
         }
-        else {
-            signedDataItem = (0, arbundles_1.createData)(Uint8Array.from(buffer), this.signer, dataItemOpts);
-            await signedDataItem.sign(this.signer);
+        catch (error) {
+            // If we have a signing emitter, emit error
+            // TODO: create a SigningError class and throw that instead of the generic Error
+            emitter?.emit('signing-error', error);
+            throw error;
         }
-        this.logger.debug('Successfully signed data item...');
-        return {
-            // while this returns a Buffer - it needs to match our return type for uploading
-            dataItemStreamFactory: () => signedDataItem.getRaw(),
-            dataItemSizeFactory: () => signedDataItem.getRaw().length,
-        };
     }
     async generateSignedRequestHeaders() {
         await this.setPublicKey();

package/lib/esm/common/events.js

@@ -0,0 +1,249 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EventEmitter } from 'eventemitter3';
+import { PassThrough, Readable } from 'stream';
+/**
+ * Creates a ReadableStream with events that emits progress and error events using the event names map.
+ *
+ * E.g.
+ *
+ * ```ts
+ * const eventNamesMap = {
+ *   'on-progress': 'signing-progress', // emits 'signing-progress' on event progress
+ *   'on-error': 'signing-error', // emits 'signing-error' errors
+ *   'on-end': 'signing-success', // emits 'signing-success' on end
+ * };
+ *
+ * const streamWithEvents = createStreamWithEvents({
+ *   data,
+ *   dataSize,
+ *   emitter,
+ *   eventNamesMap,
+ * });
+ * ```
+ */
+function createReadableStreamWithEvents({ data, dataSize, emitter, eventNamesMap, }) {
+    const originalStream = data instanceof ReadableStream
+        ? data
+        : new ReadableStream({
+            start: (controller) => {
+                controller.enqueue(data);
+                controller.close();
+            },
+        });
+    let processedBytes = 0;
+    let reader;
+    const stream = new ReadableStream({
+        start() {
+            reader = originalStream.getReader();
+        },
+        async pull(controller) {
+            try {
+                const { value, done } = await reader.read();
+                if (done) {
+                    emitter.emit(eventNamesMap['on-end']);
+                    controller.close();
+                    return;
+                }
+                processedBytes += value.length;
+                emitter.emit(eventNamesMap['on-progress'], {
+                    processedBytes,
+                    totalBytes: dataSize,
+                });
+                controller.enqueue(value);
+            }
+            catch (error) {
+                emitter.emit(eventNamesMap['on-error'], error);
+                controller.error(error);
+            }
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+    return {
+        stream,
+        resume: () => void 0, // not needed for ReadableStreams but stubbed out for type compatibility
+    };
+}
+/**
+ * Creates an eventing Readable stream that emits progress and error events.
+ *
+ * NOTE: When dealing ith Readable streams, any downstream consumer stream will need to call `resume()` once the consumer is properly set up.
+ * If we were to call it internally here, bytes would start flowing due to the configured 'data' event listener.
+ * For ReadableStreams, this is not a concern, so we stub out the resume function
+ *
+ * Example usage:
+ *
+ * ```ts
+ * const { stream, resume } = createReadableWithEvents({
+ *   data,
+ *   dataSize,
+ *   emitter,
+ *   eventNamesMap,
+ * });
+ *
+ * // setup any promise that will consume the stream (e.g. a POST request)
+ * const promise = new Promise((resolve, reject) => {
+ *   stream.on('data', (chunk) => {
+ *     resolve(chunk);
+ *   });
+ * });
+ *
+ * // allow bytes to start flowing so the promise gets the data
+ * resume();
+ *
+ * // wait for the promise to resolve
+ * const result = await promise;
+ * ```
+ */
+function createReadableWithEvents({ data, dataSize, emitter, eventNamesMap, }) {
+    const existingStream = data instanceof Readable ? data : Readable.from(data);
+    const eventingStream = new PassThrough();
+    // pause the stream to avoid emitting progress events until the stream is ready
+    existingStream.pause();
+    // add listener to emit progress events as the stream is read
+    let processedBytes = 0;
+    existingStream.on('data', (chunk) => {
+        eventingStream.write(chunk);
+        processedBytes += chunk.length;
+        emitter.emit(eventNamesMap['on-progress'], {
+            processedBytes,
+            totalBytes: dataSize,
+        });
+    });
+    existingStream.on('end', () => {
+        emitter.emit(eventNamesMap['on-end']);
+        eventingStream.end();
+    });
+    existingStream.on('error', (error) => {
+        emitter.emit(eventNamesMap['on-error'], error);
+        eventingStream.destroy(error);
+    });
+    return {
+        stream: eventingStream,
+        // allows bytes to start flowing from the original stream when the consumer is ready
+        resume: () => existingStream.resume(),
+    };
+}
+/**
+ * Creates an eventing stream from the input data that emits progress and error events
+ */
+export function createStreamWithEvents({ data, dataSize, emitter, eventNamesMap, }) {
+    if (data instanceof ReadableStream ||
+        (typeof window !== 'undefined' && data instanceof Buffer)) {
+        return createReadableStreamWithEvents({
+            data,
+            dataSize,
+            emitter,
+            eventNamesMap,
+        });
+    }
+    if (data instanceof Readable || data instanceof Buffer) {
+        return createReadableWithEvents({
+            data,
+            dataSize,
+            emitter,
+            eventNamesMap,
+        });
+    }
+    throw new Error('Invalid data or platform type');
+}
+export class TurboEventEmitter extends EventEmitter {
+    constructor({ onProgress, onError, onSuccess, onUploadProgress, onUploadError, onUploadSuccess, onSigningProgress, onSigningError, onSigningSuccess, } = {}) {
+        super();
+        if (onUploadProgress !== undefined) {
+            this.on('upload-progress', onUploadProgress);
+        }
+        if (onUploadError !== undefined) {
+            this.on('upload-error', onUploadError);
+        }
+        if (onUploadSuccess !== undefined) {
+            this.on('upload-success', onUploadSuccess);
+        }
+        if (onSigningProgress !== undefined) {
+            this.on('signing-progress', onSigningProgress);
+        }
+        if (onSigningError !== undefined) {
+            this.on('signing-error', onSigningError);
+        }
+        if (onSigningSuccess !== undefined) {
+            this.on('signing-success', onSigningSuccess);
+        }
+        if (onProgress !== undefined) {
+            this.on('overall-progress', onProgress);
+        }
+        if (onError !== undefined) {
+            this.on('overall-error', onError);
+        }
+        if (onSuccess !== undefined) {
+            this.on('overall-success', onSuccess);
+        }
+        // emit listeners for total events
+        this.on('signing-progress', (event) => {
+            this.emit('overall-progress', {
+                ...event,
+                processedBytes: event.processedBytes / 2, // since the total progress requires 2 passes through the stream, signing progress is only half of the total progress
+                totalBytes: event.totalBytes,
+                step: 'signing',
+            });
+        });
+        this.on('signing-error', (error) => {
+            this.emit('overall-error', error);
+        });
+        this.on('upload-progress', (event) => {
+            this.emit('overall-progress', {
+                ...event,
+                processedBytes: event.totalBytes / 2 + event.processedBytes / 2, // Start at 50% since signing is done, then add half of upload progress
+                totalBytes: event.totalBytes,
+                step: 'upload',
+            });
+        });
+        this.on('upload-error', (error) => {
+            this.emit('overall-error', error);
+        });
+        // NOTE: this is the last event emitted for successful upload,
+        // if another step was added (e.g. verifying optimistic caching)
+        // then this overall-success event will be emitted after that step
+        this.on('upload-success', () => {
+            this.emit('overall-success');
+        });
+    }
+}
+export function createStreamWithUploadEvents({ data, dataSize, emitter = new TurboEventEmitter(), }) {
+    return createStreamWithEvents({
+        data,
+        dataSize,
+        emitter,
+        eventNamesMap: {
+            'on-progress': 'upload-progress',
+            'on-error': 'upload-error',
+            'on-end': 'upload-success',
+        },
+    });
+}
+export function createStreamWithSigningEvents({ data, dataSize, emitter = new TurboEventEmitter(), }) {
+    return createStreamWithEvents({
+        data,
+        dataSize,
+        emitter,
+        eventNamesMap: {
+            'on-progress': 'signing-progress',
+            'on-error': 'signing-error',
+            'on-end': 'signing-success',
+        },
+    });
+}