filemail-sdk 9.4.9 → 10.0.0

package/dist/src/uploader/transferUpload.js

@@ -1,16 +1,16 @@
-import sleep from 'abortable-sleep';
-import ApiError from '../utils/api/apiError.js';
-import FsError from '../utils/fileSystem/fsError.js';
 import TransferUploadState from "./state/transferUploadState.js";
 import TransferUploadError from "./transferUploadError.js";
 import TransferStatus from "../utils/types/transferStatus.js";
 import TransferUploadEvent from './transferUploadEvent.js';
 import ChunksIterator from './chunksIterator/chunksIterator.js';
 import mergeAbortAndPauseSignals from '../utils/mergeAbortAndPauseSignals.js';
+import ApiError from '../utils/api/apiError.js';
+import FsError from '../utils/fileSystem/fsError.js';
 import ApiFilemail449Error from '../utils/api/apiFilemail449Error.js';
 import { promiseAllSettled } from '../utils/promiseAll.js';
 import { isTransferFailureAbortReason } from './transferFailureAbortReason.js';
 import { concatUint8Arrays, hexToUint8Array, uint8ArrayToHex } from '../utils/uint8ArrayUtils.js';
+const REGISTER_ITEMS_BATCH_SIZE = 250;
 export default class TransferUpload {
     #totalSizeInBytes;
     #chunkStreamProviderFactory;
@@ -19,19 +19,19 @@ export default class TransferUpload {
     #eventsEngine;
     #info;
     #config;
-    #optimizer;
+    #concurrencyController;
     #cryptography;
+    #acker;
     #transferState;
     #transferMetadata;
     #transferDownloadUrl;
+    #transferConfirmationUrl;
     #transferRecipientTrackingLinks;
     #pauseSignal;
     #abortSignal;
     #mergedPauseAndAbortSignal;
     pauseEventListener;
     abortEventListener;
-    #isUdpUploadMode;
-    #serverLatencyInMs;
     #isRunMethodRunning = false;
     get status() {
         return this.#transferState?.status ?? TransferStatus.Initialized;
@@ -62,21 +62,19 @@ export default class TransferUpload {
     get transferId() {
         return this.#transferMetadata?.transferId;
     }
-    constructor(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, info, config, optimizer, cryptography) {
+    constructor(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, info, config, concurrencyController, cryptography, acker) {
         if (info.files.length === 0)
             throw new TransferUploadError(`Files can't be empty`);
         this.#totalSizeInBytes = info.files.reduce((partialSum, file) => partialSum + file.fileSizeInBytes, 0);
-        this.#isUdpUploadMode = false;
         this.#chunkStreamProviderFactory = chunkStreamProviderFactory;
         this.#apiClient = apiClient;
         this.#fileServerClientFactory = fileServerClientFactory;
         this.#eventsEngine = eventsEngine;
         this.#info = info;
         this.#config = config;
-        this.#optimizer = optimizer;
+        this.#concurrencyController = concurrencyController;
         this.#cryptography = cryptography;
-        if (this.isUploadAppendInfo(this.#info))
-            this.createTransferMetadataFromInfo(this.#info);
+        this.#acker = acker;
     }
     isUploadAppend() {
         return this.isUploadAppendInfo(this.#info);
@@ -84,14 +82,20 @@ export default class TransferUpload {
     isUploadAppendInfo(info) {
         return info.transferKey !== undefined;
     }
-    createTransferMetadataFromInfo(info) {
-        if (!this.isUploadAppendInfo(info))
+    async registerFilesAndCreateTransferMetadataFromInfo() {
+        if (!this.isUploadAppendInfo(this.#info))
             throw new TransferUploadError(`Options are not TransferUploadAppendOptions`);
+        const registeredFiles = await this.registerTransferFilesWithValidation(this.#info.transferId, this.#info.transferKey);
+        this.createTransferMetadataFromInfo(this.#info, registeredFiles);
+        this.#eventsEngine.emit(TransferUploadEvent.RecreateDataUpdated);
+    }
+    createTransferMetadataFromInfo(info, registeredFiles) {
         this.#transferDownloadUrl = info.transferDownloadUrl;
         this.#transferMetadata = {
             transferId: info.transferId,
             transferKey: info.transferKey,
             transferFileServerUrl: info.transferFileServerUrl,
+            registeredFiles,
             transferRegion: info.transferRegion,
             encryptionData: info.e2eeData,
         };
@@ -109,27 +113,27 @@ export default class TransferUpload {
                 this.#transferState.recover();
             this.#transferState.transferRun();
             this.addPauseAndStopListeners();
-            if (!this.#transferMetadata)
+            if (this.isUploadAppend() && !this.#transferMetadata)
+                await this.registerFilesAndCreateTransferMetadataFromInfo();
+            else if (!this.#transferMetadata)
                 await this.startApiTransferAndCreateMetadata();
             this.notifyMetadataDetermined();
-            await this.pingServerAndChooseUploadMode();
-            if (this.#isUdpUploadMode && !this.#transferMetadata.udpData.handshakeData)
-                await this.serverUdpHandshake();
-            this.#optimizer.start(this.#isUdpUploadMode, this.#serverLatencyInMs);
+            this.#acker.start(this.#transferMetadata.transferId, this.#transferMetadata.transferKey, this.#transferState, transferPauseSignal, transferAbortSignal);
             const ongoingChunkUploads = new Set();
             for (const file of this.files) {
                 const fileStatus = this.#transferState.getFile(file.externalId);
                 if (fileStatus.isCompleted)
                     continue;
+                if (fileStatus.isUploadCompleted) {
+                    this.enqueueFileAck(file);
+                    continue;
+                }
                 const alreadySentChunks = this.#transferState.getChunksForFile(file.externalId);
-                const chunksIterator = new ChunksIterator(alreadySentChunks, file.fileSizeInBytes, this.#optimizer);
+                const chunksIterator = new ChunksIterator(alreadySentChunks, file.fileSizeInBytes, this.#config.chunkSizeInBytes);
                 for (const chunk of chunksIterator.getChunksIterator()) {
                     // eslint-disable-next-line no-await-in-loop
-                    const releaseSemaphore = await this.#optimizer.semaphoreAcquire();
-                    if (this.#optimizer.currentSleepTimeInMs >= 1)
-                        // eslint-disable-next-line no-await-in-loop
-                        await sleep(this.#optimizer.currentSleepTimeInMs, this.#mergedPauseAndAbortSignal);
-                    if (this.shouldStopSchedulingChunks()) {
+                    const releaseSemaphore = await this.#concurrencyController.acquire();
+                    if (this.shouldStopProcessing()) {
                         releaseSemaphore();
                         break;
                     }
@@ -138,25 +142,25 @@ export default class TransferUpload {
                         ongoingChunkUploads.delete(trackedChunkUploadPromise);
                     });
                     ongoingChunkUploads.add(trackedChunkUploadPromise);
-                    if (this.shouldStopSchedulingChunks())
+                    if (this.shouldStopProcessing())
                         break;
                 }
-                if (this.shouldStopSchedulingChunks())
+                if (this.shouldStopProcessing())
                     break;
             }
             await promiseAllSettled(Array.from(ongoingChunkUploads));
-            this.#optimizer.stop();
+            await this.#acker.flush();
             if (this.#transferState.status === TransferStatus.Pausing)
                 this.#transferState.transferPaused();
             else if (this.#transferState.status === TransferStatus.Aborting)
                 this.#transferState.transferAborted();
             // else if (this.isFailureAbortRequested())
             //     this.#transferState.transferFailed();
-            else if (this.uploadedBytesCount !== this.totalSizeInBytes)
+            else if (this.uploadedBytesCount !== this.totalSizeInBytes || this.hasUnackedFiles())
                 this.#transferState.transferFailed();
             else {
                 await this.finalizeTransfer();
-                this.#transferState.transferCompleted(this.#transferMetadata, this.#transferDownloadUrl, this.#transferRecipientTrackingLinks);
+                this.#transferState.transferCompleted(this.#transferMetadata, this.#transferDownloadUrl, this.#transferConfirmationUrl, this.#transferRecipientTrackingLinks);
             }
         }
         catch (error) {
@@ -183,8 +187,8 @@ export default class TransferUpload {
                 throw new TransferUploadError(`Unhandled error occured. See 'cause' for more details`, { cause: error });
         }
         finally {
+            await this.#acker.stop();
             this.removePauseAndStopListeners();
-            this.#optimizer.stop();
             this.#isRunMethodRunning = false;
         }
     }
@@ -198,65 +202,24 @@ export default class TransferUpload {
         };
         this.#eventsEngine.emit(TransferUploadEvent.TransferMetadataDetermined, eventArgs);
     }
-    async pingServerAndChooseUploadMode() {
-        try {
-            if (this.#config.turnOffUdp)
-                throw new Error(`UDP is turned off`);
-            const udpData = this.#transferMetadata?.udpData;
-            if (!udpData)
-                throw new Error(`No UDP data is available`);
-            const requestTimeout = this.#config.forceUdp ? 3 * 1000 : this.getPingTimeout(udpData.threshold);
-            const retryDelay = 1000;
-            const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, requestTimeout, this.#mergedPauseAndAbortSignal, undefined, retryDelay);
-            await udpClient.connect();
-            const pingResult = await udpClient.ping();
-            udpClient.close().catch(() => { });
-            this.#serverLatencyInMs = pingResult.latencyInMs;
-            this.#isUdpUploadMode = pingResult.latencyInMs >= udpData.threshold;
-            const eventArgs = { isUdpMode: this.#isUdpUploadMode, latency: pingResult.latencyInMs };
-            this.#eventsEngine.emit(TransferUploadEvent.TransferUploadModeChosen, eventArgs);
-        }
-        catch (error) {
-            this.#isUdpUploadMode = false;
-            const eventArgs = { isUdpMode: this.#isUdpUploadMode, error: error };
-            this.#eventsEngine.emit(TransferUploadEvent.TransferUploadModeChosen, eventArgs);
-        }
-    }
-    getPingTimeout(udpPingThreshold) {
-        const pingTimeout = Math.min(3 * 1000, udpPingThreshold * 20);
-        return Math.max(500, pingTimeout);
-    }
-    async serverUdpHandshake() {
-        const transferMetadata = this.#transferMetadata;
-        const udpData = transferMetadata.udpData;
-        const requestTimeout = this.getHandshakeTimeout();
-        const retryDelay = 1000;
-        const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, requestTimeout, this.#mergedPauseAndAbortSignal, undefined, retryDelay);
-        await udpClient.connect();
-        const handshakeRequest = { transferId: transferMetadata.transferId, transferKey: transferMetadata.transferKey };
-        const handshakeResponse = await udpClient.handshake(handshakeRequest);
-        udpClient.close().catch(() => { });
-        this.#transferMetadata.udpData.handshakeData = handshakeResponse;
-    }
-    getHandshakeTimeout() {
-        const timeout = Math.min(this.#serverLatencyInMs * 30, 30 * 1000);
-        return Math.max(2000, timeout);
-    }
     async sendChunkAndKeepUpdatingState(file, chunkStartPosition, chunkSizeInBytes, releaseSemaphore) {
         let uploadedBytesCount = 0;
+        const registeredFile = this.getRegisteredFile(file.externalId);
+        const uploadItemId = registeredFile?.uploadItemId;
         try {
-            this.#transferState.chunkUploadStarted(file.externalId, chunkStartPosition, chunkSizeInBytes);
+            this.#transferState.chunkUploadStarted(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes);
             const chunkStreamProvider = this.#chunkStreamProviderFactory.createChunkStreamProvider(file, chunkStartPosition, chunkSizeInBytes, this.#transferMetadata?.encryptionData);
             const progressEventHandler = (eventArgs) => {
                 uploadedBytesCount += eventArgs.transferredBytesSinceLastEvent;
-                this.#transferState.chunkUploadProgressed(file.externalId, chunkStartPosition, chunkSizeInBytes, eventArgs);
+                this.#transferState.chunkUploadProgressed(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, eventArgs);
             };
-            const response = await this.sendChunk(file, chunkStreamProvider, progressEventHandler);
-            const latencyInMsIfUdp = this.#isUdpUploadMode ? response.latencyInMs : undefined;
+            await this.sendChunk(file, registeredFile?.fileId, chunkStreamProvider, progressEventHandler);
             if (uploadedBytesCount === chunkSizeInBytes)
-                this.#transferState.chunkUploadCompleted(file.externalId, chunkStartPosition, chunkSizeInBytes, latencyInMsIfUdp);
+                this.#transferState.chunkUploadCompleted(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes);
             else
-                this.#transferState.chunkUploadCompletedPartially(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused, latencyInMsIfUdp);
+                this.#transferState.chunkUploadCompletedPartially(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
+            if (this.#transferState.getFile(file.externalId).isUploadCompleted)
+                this.enqueueFileAck(file);
         }
         catch (error) {
             const chunkError = error;
@@ -265,46 +228,22 @@ export default class TransferUpload {
                 && chunkError.cause.message === `Wrong md5 hash`
                 && this.#pauseSignal?.paused === true;
             if (isTcpPausingError)
-                this.#transferState.chunkUploadCompletedPartially(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
+                this.#transferState.chunkUploadCompletedPartially(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
             else {
                 const failedReason = this.getChunkFailedReason(error);
-                this.#transferState.chunkUploadFailed(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, failedReason, error);
+                this.#transferState.chunkUploadFailed(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, failedReason, error);
             }
         }
         finally {
             releaseSemaphore();
         }
     }
-    async sendChunk(file, chunkStreamProvider, progressEventHandler) {
-        if (this.#isUdpUploadMode)
-            return await this.sendChunkUsingUdp(file, chunkStreamProvider, progressEventHandler);
-        return await this.sendChunkUsingTcp(file, chunkStreamProvider, progressEventHandler);
-    }
-    async sendChunkUsingUdp(file, chunkStreamProvider, progressEventHandler) {
-        const transferMetadata = this.#transferMetadata;
-        const udpData = transferMetadata.udpData;
-        const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, this.#optimizer.currentRequestTimeoutInMs, this.#mergedPauseAndAbortSignal, 0);
-        const sendChunkRequest = {
-            sessionGuid: this.#transferMetadata.udpData.handshakeData.sessionGuid,
-            aesKey: this.#transferMetadata.udpData.handshakeData.aesKey,
-            chunkStartPosition: chunkStreamProvider.chunkStartPosition,
-            fileSizeInBytes: file.fileSizeInBytes,
-            fileDestinationPathInTransfer: file.fileDestinationPathInTransfer,
-            fileName: file.fileName,
-        };
-        await udpClient.connect();
-        const result = await udpClient.sendChunk(sendChunkRequest, chunkStreamProvider);
-        udpClient.close().catch(() => { });
-        const chunkProgressEventArgs = { transferredBytesTotal: chunkStreamProvider.chunkLengthInBytes, transferredBytesSinceLastEvent: chunkStreamProvider.chunkLengthInBytes };
-        progressEventHandler(chunkProgressEventArgs);
-        return result;
-    }
-    async sendChunkUsingTcp(file, chunkStreamProvider, progressEventHandler) {
+    async sendChunk(file, fileId, chunkStreamProvider, progressEventHandler) {
         const request = {
             chunkLengthInBytes: chunkStreamProvider.chunkLengthInBytes,
             chunkStartPosition: chunkStreamProvider.chunkStartPosition,
         };
-        const fileServerClient = this.#fileServerClientFactory.createFileServerTcpUploadClient(this.#transferMetadata.transferFileServerUrl, this.#transferMetadata.transferId, this.#transferMetadata.transferKey, file.fileName, file.fileDestinationPathInTransfer, file.fileSizeInBytes);
+        const fileServerClient = this.#fileServerClientFactory.createFileServerUploadClient(this.#transferMetadata.transferFileServerUrl, this.#transferMetadata.transferId, this.#transferMetadata.transferKey, file.fileName, file.fileDestinationPathInTransfer, file.fileSizeInBytes, fileId);
         const ongoingRequestPromise = fileServerClient.sendFileChunk(request, chunkStreamProvider, this.#pauseSignal, this.#abortSignal);
         fileServerClient.addEventListener(`progress`, progressEventHandler);
         await ongoingRequestPromise;
@@ -354,7 +293,7 @@ export default class TransferUpload {
         this.#pauseSignal.removeEventListener(`pause`, this.pauseEventListener);
         this.#abortSignal.removeEventListener(`abort`, this.abortEventListener);
     }
-    shouldStopSchedulingChunks() {
+    shouldStopProcessing() {
         return this.#transferState.status !== TransferStatus.Running || this.#abortSignal?.aborted === true || this.#pauseSignal?.paused === true;
     }
     isFailureAbortRequested() {
@@ -385,19 +324,73 @@ export default class TransferUpload {
                 customfields: this.#info.customFields,
             };
             const response = await this.#apiClient.initializeTransfer(request, this.#mergedPauseAndAbortSignal);
+            const registeredFiles = await this.registerTransferFilesWithValidation(response.transferId, response.transferKey);
             this.#transferMetadata = {
                 transferId: response.transferId,
                 transferKey: response.transferKey,
                 transferFileServerUrl: response.transferUrl,
+                registeredFiles,
                 transferRegion: response.transferRegion,
                 encryptionData: encryptionDataAndIvSaltHex?.encryptionData,
-                udpData: this.getResponseOrForcedUdpData(response),
             };
+            this.#eventsEngine.emit(TransferUploadEvent.RecreateDataUpdated);
         }
         catch (error) {
             throw new TransferUploadError(`Error initializing transfer through the API`, { cause: error });
         }
     }
+    async registerTransferFilesWithValidation(transferId, transferKey) {
+        const registeredFiles = new Map();
+        for (let start = 0; start < this.files.length; start += REGISTER_ITEMS_BATCH_SIZE) {
+            const filesBatch = this.files.slice(start, start + REGISTER_ITEMS_BATCH_SIZE);
+            // eslint-disable-next-line no-await-in-loop
+            const response = await this.#apiClient.registerTransferFiles(transferId, {
+                transferkey: transferKey,
+                items: filesBatch.map(file => ({
+                    path: this.joinTransferPath(file.fileDestinationPathInTransfer, file.fileName),
+                    type: `File`,
+                    size: file.fileSizeInBytes,
+                })),
+            }, this.#mergedPauseAndAbortSignal);
+            if (response.items.length !== filesBatch.length)
+                throw new TransferUploadError(`Invalid register transfer files response`);
+            response.items.forEach((item, index) => {
+                const file = filesBatch[index];
+                if (!file || !item.uploadItemId || !item.fileId)
+                    throw new TransferUploadError(`Invalid register transfer files response`);
+                registeredFiles.set(file.externalId, { uploadItemId: item.uploadItemId, fileId: item.fileId });
+            });
+        }
+        return registeredFiles;
+    }
+    joinTransferPath(directoryPath, fileName) {
+        const normalizedDirectoryPath = directoryPath.replace(/^\/+|\/+$/g, ``);
+        const normalizedFileName = fileName.replace(/^\/+/g, ``);
+        if (!normalizedDirectoryPath)
+            return normalizedFileName;
+        return `${normalizedDirectoryPath}/${normalizedFileName}`;
+    }
+    getRegisteredFile(externalFileId) {
+        return this.#transferMetadata?.registeredFiles?.get(externalFileId);
+    }
+    enqueueFileAck(file) {
+        if (this.isLegacyTransfer()) { // Remove legacy mode after all our clients migrated to app version >= 4.22
+            this.#transferState.fileCompleted(file.externalId, undefined);
+            return;
+        }
+        const registeredFile = this.getRegisteredFile(file.externalId);
+        if (!registeredFile)
+            throw new TransferUploadError(`Can't ack file with external id = ${file.externalId} - no registered file found. The transfer state is malformed.`);
+        this.#acker.enqueue({ externalFileId: file.externalId, uploadItemId: registeredFile.uploadItemId, sizeInBytes: file.fileSizeInBytes });
+    }
+    hasUnackedFiles() {
+        if (this.isLegacyTransfer())
+            return false;
+        return this.files.some(file => !this.#transferState.getFile(file.externalId).isCompleted);
+    }
+    isLegacyTransfer() {
+        return this.#transferMetadata !== undefined && this.#transferMetadata.registeredFiles === undefined;
+    }
     async generateEncryptionDataAndIvSaltHmacHex(e2eeKey) {
         if (!e2eeKey)
             return undefined;
@@ -414,14 +407,6 @@ export default class TransferUpload {
             ivSaltHmacHex,
         };
     }
-    getResponseOrForcedUdpData(response) {
-        if (!this.#config.forceUdp || !response.udp)
-            return response.udp;
-        return {
-            ...response.udp,
-            threshold: 0,
-        };
-    }
     async finalizeTransfer() {
         this.#eventsEngine.emit(TransferUploadEvent.TransferFinalizing);
         if (this.isUploadAppend())
@@ -445,10 +430,11 @@ export default class TransferUpload {
             const request = {
                 transferid: this.#transferMetadata.transferId,
                 transferkey: this.#transferMetadata.transferKey,
-                protocol: this.#isUdpUploadMode ? `udp` : `tcp`,
+                protocol: `tcp`,
             };
             const response = await this.#apiClient.finalizeTransfer(request, this.#mergedPauseAndAbortSignal);
             this.#transferDownloadUrl = response.downloadUrl;
+            this.#transferConfirmationUrl = response.confirmationUrl;
             this.#transferRecipientTrackingLinks = response.recipientTrackingLinks;
         }
         catch (error) {
@@ -457,7 +443,7 @@ export default class TransferUpload {
     }
     async cancel(abortSignal) {
         try {
-            const isTransferApiInitialized = Boolean(this.#transferState) && Boolean(this.#transferMetadata);
+            const isTransferApiInitialized = Boolean(this.#transferState) && (Boolean(this.#transferMetadata) || this.isUploadAppend());
             if (!isTransferApiInitialized) {
                 this.emitCancelEvents();
                 return;
@@ -528,19 +514,20 @@ export default class TransferUpload {
     getTransferMetadataExportValue() {
         if (!this.#transferMetadata)
             return undefined;
-        const { encryptionData, ...rest } = this.#transferMetadata;
+        const { encryptionData, registeredFiles, ...rest } = this.#transferMetadata;
         return {
             ...rest,
             encryptionData: !encryptionData ? undefined : {
                 ivHex: uint8ArrayToHex(encryptionData.iv),
                 keyHex: uint8ArrayToHex(encryptionData.key),
             },
+            registeredFiles: this.isLegacyTransfer() ? undefined : Array.from(registeredFiles.entries()),
         };
     }
-    static recreate(transferExportData, config, chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, optimizer, cryptography) {
+    static recreate(transferExportData, config, chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, concurrencyController, cryptography, acker) {
         try {
             TransferUpload.validateRecreateParams(transferExportData);
-            const transfer = new TransferUpload(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, transferExportData.info, config, optimizer, cryptography);
+            const transfer = new TransferUpload(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, transferExportData.info, config, concurrencyController, cryptography, acker);
             transfer.#transferMetadata = this.recreateTransferMetadata(transferExportData.transferMetadata);
             transfer.#transferState = new TransferUploadState(transferExportData.info.files, eventsEngine, config.currentRatesTimespanInMs, config.progressEventThrottlingInMs, transferExportData.state);
             return transfer;
@@ -555,13 +542,14 @@ export default class TransferUpload {
     static recreateTransferMetadata(transferMetadata) {
         if (!transferMetadata)
             return undefined;
-        const { encryptionData, ...rest } = transferMetadata;
+        const { encryptionData, registeredFiles, ...rest } = transferMetadata;
         return {
             ...rest,
             encryptionData: !encryptionData ? undefined : {
                 iv: hexToUint8Array(encryptionData.ivHex),
                 key: hexToUint8Array(encryptionData.keyHex),
             },
+            registeredFiles: registeredFiles ? new Map(registeredFiles) : undefined,
         };
     }
     static validateRecreateParams(transferExportData) {