@protontech/drive-sdk 0.9.9 → 0.11.0

package/src/internal/sharing/apiService.ts

@@ -36,6 +36,9 @@ type GetSharedNodesResponse =
 type GetSharedWithMeNodesResponse =
     drivePaths['/drive/v2/sharedwithme']['get']['responses']['200']['content']['application/json'];
 
+type GetSharedAlbumsResponse =
+    drivePaths['/drive/photos/albums/shared-with-me']['get']['responses']['200']['content']['application/json'];
+
 type GetInvitationsResponse =
     drivePaths['/drive/v2/shares/invitations']['get']['responses']['200']['content']['application/json'];
 
@@ -61,8 +64,10 @@ type GetShareExternalInvitations =
 type GetShareMembers =
     drivePaths['/drive/v2/shares/{shareID}/members']['get']['responses']['200']['content']['application/json'];
 
-type PostSharedBookmarksRequest =
-    Extract<drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'], {content: object}>['content']['application/json'];
+type PostSharedBookmarksRequest = Extract<
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
 type PostSharedBookmarksResponse =
     drivePaths['/drive/v2/urls/{token}/bookmark']['post']['responses']['200']['content']['application/json'];
 
@@ -73,6 +78,14 @@ type PostCreateShareRequest = Extract<
 type PostCreateShareResponse =
     drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
 
+type PostChangeSharePropertiesRequest = Extract<
+    drivePaths['/drive/shares/{shareID}/property']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+
+type PostChangeSharePropertiesResponse =
+    drivePaths['/drive/shares/{shareID}/property']['post']['responses']['200']['content']['application/json'];
+
 type PostInviteProtonUserRequest = Extract<
     drivePaths['/drive/v2/shares/{shareID}/invitations']['post']['requestBody'],
     { content: object }
@@ -184,6 +197,30 @@ export class SharingAPIService {
             }
             anchor = response.AnchorID;
         }
+
+        if (this.shareTargetTypes.includes(ShareTargetType.Album)) {
+            yield* this.iterateSharedAlbumUids(signal);
+        }
+    }
+
+    // TODO: Sharing cannot know about albums. We should remove this and use
+    // ShareTargetTypes when it is supported by the API.
+    private async *iterateSharedAlbumUids(signal?: AbortSignal): AsyncGenerator<string> {
+        let anchor = '';
+        while (true) {
+            const response = await this.apiService.get<GetSharedAlbumsResponse>(
+                `drive/photos/albums/shared-with-me?${anchor ? `AnchorID=${anchor}` : ''}`,
+                signal,
+            );
+            for (const album of response.Albums) {
+                yield makeNodeUid(album.VolumeID, album.LinkID);
+            }
+
+            if (!response.More || !response.AnchorID) {
+                break;
+            }
+            anchor = response.AnchorID;
+        }
     }
 
     async *iterateInvitationUids(signal?: AbortSignal): AsyncGenerator<string> {
@@ -304,7 +341,7 @@ export class SharingAPIService {
         addressId: string;
         addressKeyId: string;
     }): Promise<void> {
-         await this.apiService.post<PostSharedBookmarksRequest, PostSharedBookmarksResponse>(
+        await this.apiService.post<PostSharedBookmarksRequest, PostSharedBookmarksResponse>(
             `drive/v2/urls/${bookmark.token}/bookmark`,
             {
                 BookmarkShareURL: {
@@ -363,7 +400,7 @@ export class SharingAPIService {
             base64PassphraseKeyPacket: string;
             base64NameKeyPacket: string;
         },
-    ): Promise<string> {
+    ): Promise<{ shareId: string; editorsCanShare: boolean }> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
         const response = await this.apiService.post<PostCreateShareRequest, PostCreateShareResponse>(
             `drive/volumes/${volumeId}/shares`,
@@ -378,13 +415,20 @@ export class SharingAPIService {
                 NameKeyPacket: node.base64NameKeyPacket,
             },
         );
-        return response.Share.ID;
+        return { shareId: response.Share.ID, editorsCanShare: response.Share.EditorsCanShare };
     }
 
     async deleteShare(shareId: string, force: boolean = false): Promise<void> {
         await this.apiService.delete(`drive/shares/${shareId}?Force=${force ? 1 : 0}`);
     }
 
+    async changeShareProperties(shareId: string, { editorsCanShare }: { editorsCanShare: boolean }) {
+        await this.apiService.post<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
+            `drive/shares/${shareId}/property`,
+            { EditorsCanShare: editorsCanShare },
+        );
+    }
+
     async inviteProtonUser(
         shareId: string,
         invitation: EncryptedInvitationRequest,

package/src/internal/sharing/cryptoService.ts

@@ -213,7 +213,7 @@ export class SharingCryptoService {
         } catch (error: unknown) {
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt item name: ${message}`;
-            nodeName = resultError(new Error(errorMessage));
+            nodeName = resultError(new Error(errorMessage, { cause: error }));
         }
 
         return {
@@ -458,7 +458,10 @@ export class SharingCryptoService {
             urlPassword = result.password;
             customPassword = resultOk(result.customPassword);
         } catch (originalError: unknown) {
-            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            const error =
+                originalError instanceof Error
+                    ? originalError
+                    : new Error(c('Error').t`Unknown error`, { cause: originalError });
             return {
                 url: resultError(error),
                 customPassword: resultError(error),
@@ -473,7 +476,10 @@ export class SharingCryptoService {
         try {
             shareKey = await this.decryptBookmarkKey(encryptedBookmark, password);
         } catch (originalError: unknown) {
-            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            const error =
+                originalError instanceof Error
+                    ? originalError
+                    : new Error(c('Error').t`Unknown error`, { cause: originalError });
             return {
                 url,
                 customPassword,
@@ -577,7 +583,7 @@ export class SharingCryptoService {
 
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt bookmark name: ${message}`;
-            return resultError(new Error(errorMessage));
+            return resultError(new Error(errorMessage, { cause: error }));
         }
     }
 }

package/src/internal/sharing/sharingManagement.test.ts

@@ -18,6 +18,8 @@ import { SharingManagement } from './sharingManagement';
 import { ValidationError } from '../../errors';
 import { ErrorCode } from '../apiService';
 
+const DEFAULT_SHARE_ID = 'shareId';
+
 describe('SharingManagement', () => {
     let logger: Logger;
     let apiService: SharingAPIService;
@@ -34,7 +36,7 @@ describe('SharingManagement', () => {
 
         // @ts-expect-error No need to implement all methods for mocking
         apiService = {
-            createStandardShare: jest.fn().mockReturnValue('newShareId'),
+            createStandardShare: jest.fn().mockReturnValue({ shareId: 'newShareId', editorsCanShare: false }),
             getShareInvitations: jest.fn().mockResolvedValue([]),
             getShareExternalInvitations: jest.fn().mockResolvedValue([]),
             getShareMembers: jest.fn().mockResolvedValue([]),
@@ -63,6 +65,7 @@ describe('SharingManagement', () => {
                 publicUrl: 'publicLinkUrl',
             }),
             updatePublicLink: jest.fn(),
+            changeShareProperties: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
@@ -98,7 +101,7 @@ describe('SharingManagement', () => {
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
             loadEncryptedShare: jest.fn().mockResolvedValue({
-                id: 'shareId',
+                id: DEFAULT_SHARE_ID,
                 addressId: 'addressId',
                 creatorEmail: 'address@example.com',
                 passphraseSessionKey: 'sharePassphraseSessionKey',
@@ -106,9 +109,11 @@ describe('SharingManagement', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
-            getNode: jest
-                .fn()
-                .mockImplementation((nodeUid) => ({ nodeUid, shareId: 'shareId', name: { ok: true, value: 'name' } })),
+            getNode: jest.fn().mockImplementation((nodeUid) => ({
+                nodeUid,
+                shareId: DEFAULT_SHARE_ID,
+                name: { ok: true, value: 'name' },
+            })),
             getNodeKeys: jest.fn().mockImplementation((nodeUid) => ({ key: 'node-key' })),
             getNodePrivateAndSessionKeys: jest.fn().mockImplementation((nodeUid) => ({})),
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'volume-email', addressKey: 'volume-key' }),
@@ -225,6 +230,7 @@ describe('SharingManagement', () => {
                 nonProtonInvitations: [],
                 members: [],
                 publicLink: undefined,
+                editorsCanShare: false,
             });
             expect(apiService.updateInvitation).not.toHaveBeenCalled();
             expect(apiService.inviteProtonUser).toHaveBeenCalled();
@@ -395,6 +401,28 @@ describe('SharingManagement', () => {
                 expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
+            it('should update editorsCanChange', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    editorsCanShare: true,
+                });
+
+                expect(sharingInfo).toEqual({
+                    protonInvitations: [
+                        {
+                            ...invitation,
+                            role: 'viewer',
+                        },
+                    ],
+                    nonProtonInvitations: [externalInvitation],
+                    members: [member],
+                    publicLink: undefined,
+                    editorsCanShare: true,
+                });
+                expect(apiService.changeShareProperties).toHaveBeenCalledWith(DEFAULT_SHARE_ID, {
+                    editorsCanShare: true,
+                });
+            });
+
             it('should be no-op if no change', async () => {
                 const sharingInfo = await sharingManagement.shareNode(nodeUid, {
                     users: [{ email: 'internal-email', role: MemberRole.Viewer }],

package/src/internal/sharing/sharingManagement.ts

@@ -77,11 +77,12 @@ export class SharingManagement {
             return;
         }
 
-        const [protonInvitations, nonProtonInvitations, members, publicLink] = await Promise.all([
+        const [protonInvitations, nonProtonInvitations, members, publicLink, share] = await Promise.all([
             Array.fromAsync(this.iterateShareInvitations(node.shareId)),
             Array.fromAsync(this.iterateShareExternalInvitations(node.shareId)),
             Array.fromAsync(this.iterateShareMembers(node.shareId)),
             this.getPublicLink(node.shareId),
+            this.sharesService.loadEncryptedShare(node.shareId),
         ]);
 
         return {
@@ -89,6 +90,7 @@ export class SharingManagement {
             nonProtonInvitations,
             members,
             publicLink,
+            editorsCanShare: share.editorsCanShare,
         };
     }
 
@@ -161,6 +163,7 @@ export class SharingManagement {
                     nonProtonInvitations: [],
                     members: [],
                     publicLink: undefined,
+                    editorsCanShare: result.editorsCanShare,
                 };
                 contextShareAddress = result.contextShareAddress;
             } catch (error: unknown) {
@@ -184,6 +187,11 @@ export class SharingManagement {
             contextShareAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
         }
 
+        if (settings.editorsCanShare !== undefined) {
+            await this.setEditorsCanShare(currentSharing.share.shareId, settings.editorsCanShare);
+            currentSharing.editorsCanShare = settings.editorsCanShare;
+        }
+
         const emailOptions: EmailOptions = {
             message: settings.emailOptions?.message,
             nodeName: settings.emailOptions?.includeNodeName ? currentSharing.nodeName : undefined,
@@ -294,6 +302,7 @@ export class SharingManagement {
             nonProtonInvitations: currentSharing.nonProtonInvitations,
             members: currentSharing.members,
             publicLink: currentSharing.publicLink,
+            editorsCanShare: currentSharing.editorsCanShare,
         };
     }
 
@@ -385,6 +394,7 @@ export class SharingManagement {
             nonProtonInvitations: currentSharing.nonProtonInvitations,
             members: currentSharing.members,
             publicLink: currentSharing.publicLink,
+            editorsCanShare: currentSharing.editorsCanShare,
         };
     }
 
@@ -415,7 +425,9 @@ export class SharingManagement {
         };
     }
 
-    private async createShare(nodeUid: string): Promise<{ share: Share; contextShareAddress: ContextShareAddress }> {
+    private async createShare(
+        nodeUid: string,
+    ): Promise<{ share: Share; contextShareAddress: ContextShareAddress; editorsCanShare: boolean }> {
         const node = await this.nodesService.getNode(nodeUid);
         if (!node.parentUid) {
             throw new ValidationError(c('Error').t`Cannot share root folder`);
@@ -426,10 +438,15 @@ export class SharingManagement {
 
         const nodeKeys = await this.nodesService.getNodePrivateAndSessionKeys(nodeUid);
         const keys = await this.cryptoService.generateShareKeys(nodeKeys, addressKey);
-        const shareId = await this.apiService.createStandardShare(nodeUid, addressId, keys.shareKey.encrypted, {
-            base64PassphraseKeyPacket: keys.base64PpassphraseKeyPacket,
-            base64NameKeyPacket: keys.base64NameKeyPacket,
-        });
+        const { shareId, editorsCanShare } = await this.apiService.createStandardShare(
+            nodeUid,
+            addressId,
+            keys.shareKey.encrypted,
+            {
+                base64PassphraseKeyPacket: keys.base64PpassphraseKeyPacket,
+                base64NameKeyPacket: keys.base64NameKeyPacket,
+            },
+        );
         await this.nodesService.notifyNodeChanged(nodeUid);
         if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
             await this.cache.addSharedByMeNodeUid(nodeUid);
@@ -449,9 +466,14 @@ export class SharingManagement {
         return {
             share,
             contextShareAddress,
+            editorsCanShare,
         };
     }
 
+    private async setEditorsCanShare(shareId: string, editorsCanShare: boolean) {
+        await this.apiService.changeShareProperties(shareId, { editorsCanShare });
+    }
+
     /**
      * Deletes the share even if it is not empty.
      */

package/src/internal/sharingPublic/nodes.ts

@@ -18,7 +18,7 @@ import { SharingPublicSharesManager } from './shares';
 
 export class SharingPublicNodesCryptoService extends NodesCryptoService {
     async generateDocument(
-        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,
         name: string,
     ) {

package/src/internal/upload/apiService.ts

@@ -142,7 +142,7 @@ export class UploadAPIService {
     }
 
     async getVerificationData(draftNodeRevisionUid: string): Promise<{
-        verificationCode: Uint8Array;
+        verificationCode: Uint8Array<ArrayBuffer>;
         base64ContentKeyPacket: string;
     }> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
@@ -162,22 +162,24 @@ export class UploadAPIService {
         blocks: {
             contentBlocks: {
                 index: number;
-                hash: Uint8Array;
-                encryptedSize: number;
                 armoredSignature: string;
-                verificationToken: Uint8Array;
+                verificationToken: Uint8Array<ArrayBuffer>;
             }[];
             thumbnails?: {
                 type: ThumbnailType;
-                hash: Uint8Array;
-                encryptedSize: number;
             }[];
         },
     ): Promise<UploadTokens> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
         const result = await this.apiService.post<
             // TODO: Deprected fields but not properly marked in the types.
-            Omit<PostRequestBlockUploadRequest, 'ShareID' | 'Thumbnail' | 'ThumbnailHash' | 'ThumbnailSize'>,
+            Omit<
+                PostRequestBlockUploadRequest,
+                'ShareID' | 'Thumbnail' | 'ThumbnailHash' | 'ThumbnailSize' | 'BlockList' | 'ThumbnailList'
+            > & {
+                BlockList: Omit<PostRequestBlockUploadRequest['BlockList'][0], 'Hash' | 'Size'>[];
+                ThumbnailList: Omit<PostRequestBlockUploadRequest['ThumbnailList'][0], 'Hash' | 'Size'>[];
+            },
             PostRequestBlockUploadResponse
         >('drive/blocks', {
             AddressID: addressId,
@@ -186,16 +188,12 @@ export class UploadAPIService {
             RevisionID: revisionId,
             BlockList: blocks.contentBlocks.map((block) => ({
                 Index: block.index,
-                Hash: uint8ArrayToBase64String(block.hash),
                 EncSignature: block.armoredSignature,
-                Size: block.encryptedSize,
                 Verifier: {
                     Token: uint8ArrayToBase64String(block.verificationToken),
                 },
             })),
             ThumbnailList: (blocks.thumbnails || []).map((block) => ({
-                Hash: uint8ArrayToBase64String(block.hash),
-                Size: block.encryptedSize,
                 Type: block.type,
             })),
         });
@@ -260,7 +258,7 @@ export class UploadAPIService {
     async uploadBlock(
         url: string,
         token: string,
-        block: Uint8Array,
+        block: Uint8Array<ArrayBuffer>,
         onProgress?: (uploadedBytes: number) => void,
         signal?: AbortSignal,
     ): Promise<void> {

package/src/internal/upload/blockVerifier.ts

@@ -3,7 +3,7 @@ import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 
 export class BlockVerifier {
-    private verificationCode?: Uint8Array;
+    private verificationCode?: Uint8Array<ArrayBuffer>;
     private contentKeyPacketSessionKey?: SessionKey;
 
     constructor(
@@ -26,8 +26,8 @@ export class BlockVerifier {
         );
     }
 
-    async verifyBlock(encryptedBlock: Uint8Array): Promise<{
-        verificationToken: Uint8Array;
+    async verifyBlock(encryptedBlock: Uint8Array<ArrayBuffer>): Promise<{
+        verificationToken: Uint8Array<ArrayBuffer>;
     }> {
         if (!this.verificationCode || !this.contentKeyPacketSessionKey) {
             throw new Error('Verifying block before loading verification data');

package/src/internal/upload/chunkStreamReader.test.ts

@@ -1,10 +1,10 @@
 import { ChunkStreamReader } from './chunkStreamReader';
 
 describe('ChunkStreamReader', () => {
-    let stream: ReadableStream<Uint8Array>;
+    let stream: ReadableStream<Uint8Array<ArrayBuffer>>;
 
     beforeEach(() => {
-        stream = new ReadableStream<Uint8Array>({
+        stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
             start(controller) {
                 controller.enqueue(new Uint8Array([1, 2, 3]));
                 controller.enqueue(new Uint8Array([4, 5, 6]));
@@ -18,7 +18,7 @@ describe('ChunkStreamReader', () => {
     it('should yield chunks as enqueued if matching the size', async () => {
         const reader = new ChunkStreamReader(stream, 3);
 
-        const chunks: Uint8Array[] = [];
+        const chunks: Uint8Array<ArrayBuffer>[] = [];
         for await (const chunk of reader.iterateChunks()) {
             chunks.push(new Uint8Array(chunk));
         }
@@ -33,7 +33,7 @@ describe('ChunkStreamReader', () => {
     it('should yield smaller chunks than enqueued chunks', async () => {
         const reader = new ChunkStreamReader(stream, 2);
 
-        const chunks: Uint8Array[] = [];
+        const chunks: Uint8Array<ArrayBuffer>[] = [];
         for await (const chunk of reader.iterateChunks()) {
             chunks.push(new Uint8Array(chunk));
         }
@@ -50,7 +50,7 @@ describe('ChunkStreamReader', () => {
     it('should yield bigger chunks than enqueued chunks', async () => {
         const reader = new ChunkStreamReader(stream, 4);
 
-        const chunks: Uint8Array[] = [];
+        const chunks: Uint8Array<ArrayBuffer>[] = [];
         for await (const chunk of reader.iterateChunks()) {
             chunks.push(new Uint8Array(chunk));
         }
@@ -64,7 +64,7 @@ describe('ChunkStreamReader', () => {
     it('should yield last incomplete chunk', async () => {
         const reader = new ChunkStreamReader(stream, 5);
 
-        const chunks: Uint8Array[] = [];
+        const chunks: Uint8Array<ArrayBuffer>[] = [];
         for await (const chunk of reader.iterateChunks()) {
             chunks.push(new Uint8Array(chunk));
         }
@@ -78,7 +78,7 @@ describe('ChunkStreamReader', () => {
     it('should yield as one big chunk', async () => {
         const reader = new ChunkStreamReader(stream, 100);
 
-        const chunks: Uint8Array[] = [];
+        const chunks: Uint8Array<ArrayBuffer>[] = [];
         for await (const chunk of reader.iterateChunks()) {
             chunks.push(new Uint8Array(chunk));
         }

package/src/internal/upload/chunkStreamReader.ts

@@ -6,16 +6,16 @@
  * If you need to keep previous chunks, copy them to a new array.
  */
 export class ChunkStreamReader {
-    private reader: ReadableStreamDefaultReader<Uint8Array>;
+    private reader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>;
 
     private chunkSize: number;
 
-    constructor(stream: ReadableStream<Uint8Array>, chunkSize: number) {
+    constructor(stream: ReadableStream<Uint8Array<ArrayBuffer>>, chunkSize: number) {
         this.reader = stream.getReader();
         this.chunkSize = chunkSize;
     }
 
-    async *iterateChunks(): AsyncGenerator<Uint8Array> {
+    async *iterateChunks(): AsyncGenerator<Uint8Array<ArrayBuffer>> {
         const buffer = new Uint8Array(this.chunkSize);
 
         let position = 0;

package/src/internal/upload/cryptoService.ts

@@ -23,7 +23,7 @@ export class UploadCryptoService {
 
     async generateFileCrypto(
         parentUid: string,
-        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         name: string,
     ): Promise<NodeCrypto> {
         const signingKeys = await this.getSigningKeys({ parentNodeUid: parentUid });
@@ -111,21 +111,21 @@ export class UploadCryptoService {
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
 
-        const digest = await crypto.subtle.digest('SHA-256', encryptedData);
+        const digestPromise = crypto.subtle.digest('SHA-256', encryptedData);
 
         return {
             type: thumbnail.type,
             encryptedData: encryptedData,
             originalSize: thumbnail.thumbnail.length,
             encryptedSize: encryptedData.length,
-            hash: new Uint8Array(digest),
+            hashPromise: digestPromise.then((digest) => new Uint8Array<ArrayBuffer>(digest)),
         };
     }
 
     async encryptBlock(
-        verifyBlock: (encryptedBlock: Uint8Array) => Promise<{ verificationToken: Uint8Array }>,
+        verifyBlock: (encryptedBlock: Uint8Array<ArrayBuffer>) => Promise<{ verificationToken: Uint8Array<ArrayBuffer> }>,
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
-        block: Uint8Array,
+        block: Uint8Array<ArrayBuffer>,
         index: number,
     ): Promise<EncryptedBlock> {
         const { encryptedData, armoredSignature } = await this.driveCrypto.encryptBlock(
@@ -134,8 +134,7 @@ export class UploadCryptoService {
             nodeRevisionDraftKeys.contentKeyPacketSessionKey,
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
-
-        const digest = await crypto.subtle.digest('SHA-256', encryptedData);
+        const digestPromise = crypto.subtle.digest('SHA-256', encryptedData);
         const { verificationToken } = await verifyBlock(encryptedData);
 
         return {
@@ -145,13 +144,13 @@ export class UploadCryptoService {
             verificationToken,
             originalSize: block.length,
             encryptedSize: encryptedData.length,
-            hash: new Uint8Array(digest),
+            hashPromise: digestPromise.then((digest) => new Uint8Array<ArrayBuffer>(digest)),
         };
     }
 
     async commitFile(
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
-        manifest: Uint8Array,
+        manifest: Uint8Array<ArrayBuffer>,
         extendedAttributes?: string,
     ): Promise<{
         armoredManifestSignature: string;
@@ -190,10 +189,10 @@ export class UploadCryptoService {
 
     async verifyBlock(
         contentKeyPacketSessionKey: SessionKey,
-        verificationCode: Uint8Array,
-        encryptedData: Uint8Array,
+        verificationCode: Uint8Array<ArrayBuffer>,
+        encryptedData: Uint8Array<ArrayBuffer>,
     ): Promise<{
-        verificationToken: Uint8Array;
+        verificationToken: Uint8Array<ArrayBuffer>;
     }> {
         // Attempt to decrypt data block, to try to detect bitflips / bad hardware
         //

package/src/internal/upload/interface.ts

@@ -8,7 +8,7 @@ export type NodeRevisionDraft = {
     nodeRevisionUid: string;
     nodeKeys: NodeRevisionDraftKeys;
     parentNodeKeys?: {
-        hashKey: Uint8Array;
+        hashKey: Uint8Array<ArrayBuffer>;
     };
     // newNodeInfo is set only when revision is created with the new node.
     newNodeInfo?: {
@@ -64,19 +64,19 @@ export type NodeCryptoSigningKeys = {
 export type EncryptedBlockMetadata = {
     encryptedSize: number;
     originalSize: number;
-    hash: Uint8Array;
+    hashPromise: Promise<Uint8Array<ArrayBuffer>>;
 };
 
 export type EncryptedBlock = EncryptedBlockMetadata & {
     index: number;
-    encryptedData: Uint8Array;
+    encryptedData: Uint8Array<ArrayBuffer>;
     armoredSignature: string;
-    verificationToken: Uint8Array;
+    verificationToken: Uint8Array<ArrayBuffer>;
 };
 
 export type EncryptedThumbnail = EncryptedBlockMetadata & {
     type: ThumbnailType;
-    encryptedData: Uint8Array;
+    encryptedData: Uint8Array<ArrayBuffer>;
 };
 
 export type UploadTokens = {
@@ -101,7 +101,7 @@ export interface NodesService {
         key: PrivateKey;
         passphraseSessionKey: SessionKey;
         contentKeyPacketSessionKey?: SessionKey;
-        hashKey?: Uint8Array;
+        hashKey?: Uint8Array<ArrayBuffer>;
     }>;
     getNodeSigningKeys(
         uids: { nodeUid: string; parentNodeUid?: string } | { nodeUid?: string; parentNodeUid: string },

package/src/internal/upload/manager.ts

@@ -73,7 +73,7 @@ export class UploadManager {
 
     private async createDraftOnAPI(
         parentFolderUid: string,
-        parentHashKey: Uint8Array,
+        parentHashKey: Uint8Array<ArrayBuffer>,
         name: string,
         metadata: UploadMetadata,
         generatedNodeCrypto: NodeCrypto,
@@ -226,7 +226,7 @@ export class UploadManager {
 
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
-        manifest: Uint8Array,
+        manifest: Uint8Array<ArrayBuffer>,
         extendedAttributes: {
             modificationTime?: Date;
             size: number;