@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/upload/apiService.ts

@@ -1,53 +1,85 @@
-import { c } from "ttag";
+import { c } from 'ttag';
 
-import { base64StringToUint8Array, uint8ArrayToBase64String } from "../../crypto";
-import { APICodeError, DriveAPIService, drivePaths, isCodeOk } from "../apiService";
-import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid } from "../uids";
-import { UploadTokens } from "./interface";
-import { ThumbnailType } from "../../interface";
+import { base64StringToUint8Array, uint8ArrayToBase64String } from '../../crypto';
+import { APICodeError, DriveAPIService, drivePaths, isCodeOk } from '../apiService';
+import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid } from '../uids';
+import { UploadTokens } from './interface';
+import { ThumbnailType } from '../../interface';
 
-type PostCheckAvailableHashesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCheckAvailableHashesResponse = drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['responses']['200']['content']['application/json'];
+type PostCheckAvailableHashesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCheckAvailableHashesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['responses']['200']['content']['application/json'];
 
-type PostCreateDraftRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCreateDraftResponse = drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['responses']['200']['content']['application/json'];
+type PostCreateDraftRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateDraftResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['responses']['200']['content']['application/json'];
 
-type PostCreateDraftRevisionRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCreateDraftRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['post']['responses']['200']['content']['application/json'];
+type PostCreateDraftRevisionRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateDraftRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['post']['responses']['200']['content']['application/json'];
 
-type GetVerificationDataResponse = drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/revisions/{revisionID}/verification']['get']['responses']['200']['content']['application/json'];
+type GetVerificationDataResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/revisions/{revisionID}/verification']['get']['responses']['200']['content']['application/json'];
 
-type PostRequestBlockUploadRequest = Extract<drivePaths['/drive/blocks']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostRequestBlockUploadResponse = drivePaths['/drive/blocks']['post']['responses']['200']['content']['application/json'];
+type PostRequestBlockUploadRequest = Extract<
+    drivePaths['/drive/blocks']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostRequestBlockUploadResponse =
+    drivePaths['/drive/blocks']['post']['responses']['200']['content']['application/json'];
 
-type PostCommitRevisionRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCommitRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['responses']['200']['content']['application/json'];
+type PostCommitRevisionRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCommitRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['responses']['200']['content']['application/json'];
 
-type PostDeleteNodesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostDeleteNodesResponse = drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['responses']['200']['content']['application/json'];
+type PostDeleteNodesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostDeleteNodesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['responses']['200']['content']['application/json'];
 
 export class UploadAPIService {
-    constructor(private apiService: DriveAPIService) {
+    constructor(
+        private apiService: DriveAPIService,
+        private clientUid: string | undefined,
+    ) {
         this.apiService = apiService;
+        this.clientUid = clientUid;
     }
 
-    async checkAvailableHashes(parentNodeUid: string, hashes: string[]): Promise<{
-        availalbleHashes: string[],
+    async checkAvailableHashes(
+        parentNodeUid: string,
+        hashes: string[],
+    ): Promise<{
+        availalbleHashes: string[];
         pendingHashes: {
-            hash: string,
-            nodeUid: string,
-            revisionUid: string,
-            clientUid?: string,
-        }[],
+            hash: string;
+            nodeUid: string;
+            revisionUid: string;
+            clientUid?: string;
+        }[];
     }> {
         const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
-        const result = await this.apiService.post<
-            PostCheckAvailableHashesRequest,
-            PostCheckAvailableHashesResponse
-        >(`drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`, {
-            Hashes: hashes,
-            ClientUID: null,
-        });
+        const result = await this.apiService.post<PostCheckAvailableHashesRequest, PostCheckAvailableHashesResponse>(
+            `drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`,
+            {
+                Hashes: hashes,
+                ClientUID: this.clientUid ? [this.clientUid] : null,
+            },
+        );
 
         return {
             availalbleHashes: result.AvailableHashes,
@@ -57,103 +89,111 @@ export class UploadAPIService {
                 revisionUid: makeNodeRevisionUid(volumeId, hash.LinkID, hash.RevisionID),
                 clientUid: hash.ClientUID || undefined,
             })),
-        }
+        };
     }
 
-    async createDraft(parentNodeUid: string, node: {
-        armoredEncryptedName: string,
-        hash: string,
-        mediaType: string,
-        clientUID?: string,
-        intendedUploadSize?: number,
-        armoredNodeKey: string,
-        armoredNodePassphrase: string,
-        armoredNodePassphraseSignature: string,
-        base64ContentKeyPacket: string,
-        armoredContentKeyPacketSignature: string,
-        signatureEmail: string,
-    }): Promise<{
-        nodeUid: string,
-        nodeRevisionUid: string,
+    async createDraft(
+        parentNodeUid: string,
+        node: {
+            armoredEncryptedName: string;
+            hash: string;
+            mediaType: string;
+            intendedUploadSize?: number;
+            armoredNodeKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            base64ContentKeyPacket: string;
+            armoredContentKeyPacketSignature: string;
+            signatureEmail: string;
+        },
+    ): Promise<{
+        nodeUid: string;
+        nodeRevisionUid: string;
     }> {
         const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
-        const result = await this.apiService.post<
-            PostCreateDraftRequest,
-            PostCreateDraftResponse
-        >(`drive/v2/volumes/${volumeId}/files`, {
-            ParentLinkID: parentNodeId,
-            Name: node.armoredEncryptedName,
-            Hash: node.hash,
-            MIMEType: node.mediaType,
-            ClientUID: node.clientUID || null,
-            IntendedUploadSize: node.intendedUploadSize || null,
-            NodeKey: node.armoredNodeKey,
-            NodePassphrase: node.armoredNodePassphrase,
-            NodePassphraseSignature: node.armoredNodePassphraseSignature,
-            ContentKeyPacket: node.base64ContentKeyPacket,
-            ContentKeyPacketSignature: node.armoredContentKeyPacketSignature,
-            SignatureAddress: node.signatureEmail,
-        });
+        const result = await this.apiService.post<PostCreateDraftRequest, PostCreateDraftResponse>(
+            `drive/v2/volumes/${volumeId}/files`,
+            {
+                ParentLinkID: parentNodeId,
+                Name: node.armoredEncryptedName,
+                Hash: node.hash,
+                MIMEType: node.mediaType,
+                ClientUID: this.clientUid || null,
+                IntendedUploadSize: node.intendedUploadSize || null,
+                NodeKey: node.armoredNodeKey,
+                NodePassphrase: node.armoredNodePassphrase,
+                NodePassphraseSignature: node.armoredNodePassphraseSignature,
+                ContentKeyPacket: node.base64ContentKeyPacket,
+                ContentKeyPacketSignature: node.armoredContentKeyPacketSignature,
+                SignatureAddress: node.signatureEmail,
+            },
+        );
 
         return {
             nodeUid: makeNodeUid(volumeId, result.File.ID),
             nodeRevisionUid: makeNodeRevisionUid(volumeId, result.File.ID, result.File.RevisionID),
-        }
+        };
     }
 
-    async createDraftRevision(nodeUid: string, revision: {
-        currentRevisionUid: string,
-        clientUID?: string,
-        intendedUploadSize?: number,
-    }): Promise<{
-        nodeRevisionUid: string,
+    async createDraftRevision(
+        nodeUid: string,
+        revision: {
+            currentRevisionUid: string;
+            intendedUploadSize?: number;
+        },
+    ): Promise<{
+        nodeRevisionUid: string;
     }> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
         const { revisionId: currentRevisionId } = splitNodeRevisionUid(revision.currentRevisionUid);
-        
-        const result = await this.apiService.post<
-            PostCreateDraftRevisionRequest,
-            PostCreateDraftRevisionResponse
-        >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions`, {
-            CurrentRevisionID: currentRevisionId,
-            ClientUID: revision.clientUID || null,
-            IntendedUploadSize: revision.intendedUploadSize || null,
-        });
+
+        const result = await this.apiService.post<PostCreateDraftRevisionRequest, PostCreateDraftRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions`,
+            {
+                CurrentRevisionID: currentRevisionId,
+                ClientUID: this.clientUid || null,
+                IntendedUploadSize: revision.intendedUploadSize || null,
+            },
+        );
 
         return {
             nodeRevisionUid: makeNodeRevisionUid(volumeId, nodeId, result.Revision.ID),
-        }
+        };
     }
 
     async getVerificationData(draftNodeRevisionUid: string): Promise<{
-        verificationCode: Uint8Array,
-        base64ContentKeyPacket: string,
+        verificationCode: Uint8Array;
+        base64ContentKeyPacket: string;
     }> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
-        const result = await this.apiService.get<
-            GetVerificationDataResponse
-        >(`drive/v2/volumes/${volumeId}/links/${nodeId}/revisions/${revisionId}/verification`);
-        
+        const result = await this.apiService.get<GetVerificationDataResponse>(
+            `drive/v2/volumes/${volumeId}/links/${nodeId}/revisions/${revisionId}/verification`,
+        );
+
         return {
             verificationCode: base64StringToUint8Array(result.VerificationCode),
             base64ContentKeyPacket: result.ContentKeyPacket,
-        }
+        };
     }
 
-    async requestBlockUpload(draftNodeRevisionUid: string, addressId: string, blocks: {
-        contentBlocks: {
-            index: number,
-            hash: Uint8Array,
-            encryptedSize: number,
-            armoredSignature: string,
-            verificationToken: Uint8Array,
-        }[],
-        thumbnails?: {
-            type: ThumbnailType,
-            hash: Uint8Array,
-            encryptedSize: number,
-        }[],
-    }): Promise<UploadTokens> {
+    async requestBlockUpload(
+        draftNodeRevisionUid: string,
+        addressId: string,
+        blocks: {
+            contentBlocks: {
+                index: number;
+                hash: Uint8Array;
+                encryptedSize: number;
+                armoredSignature: string;
+                verificationToken: Uint8Array;
+            }[];
+            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.
@@ -195,11 +235,14 @@ export class UploadAPIService {
         };
     }
 
-    async commitDraftRevision(draftNodeRevisionUid: string, options: {
-        armoredManifestSignature: string,
-        signatureEmail: string,
-        armoredExtendedAttributes?: string,
-    }): Promise<void> {
+    async commitDraftRevision(
+        draftNodeRevisionUid: string,
+        options: {
+            armoredManifestSignature: string;
+            signatureEmail: string;
+            armoredExtendedAttributes?: string;
+        },
+    ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
         await this.apiService.put<
             // TODO: Deprected fields but not properly marked in the types.
@@ -216,16 +259,16 @@ export class UploadAPIService {
     async deleteDraft(draftNodeUid: string): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(draftNodeUid);
 
-        const response = await this.apiService.post<
-            PostDeleteNodesRequest,
-            PostDeleteNodesResponse
-        >(`drive/v2/volumes/${volumeId}/delete_multiple`, {
-            LinkIDs: [nodeId],
-        });
+        const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
+            `drive/v2/volumes/${volumeId}/delete_multiple`,
+            {
+                LinkIDs: [nodeId],
+            },
+        );
 
         const code = response.Responses?.[0].Response.Code || 0;
         if (!isCodeOk(code)) {
-            throw new APICodeError(c('Error').t`Unknown error ${code}`, code)
+            throw new APICodeError(c('Error').t`Unknown error ${code}`, code);
         }
     }
 
@@ -234,9 +277,15 @@ export class UploadAPIService {
         await this.apiService.delete(`/drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`);
     }
 
-    async uploadBlock(url: string, token: string, block: Uint8Array, onProgress?: (uploadedBytes: number) => void, signal?: AbortSignal): Promise<void> {
+    async uploadBlock(
+        url: string,
+        token: string,
+        block: Uint8Array,
+        onProgress?: (uploadedBytes: number) => void,
+        signal?: AbortSignal,
+    ): Promise<void> {
         const formData = new FormData();
-        formData.append("Block", new Blob([block]), "blob");
+        formData.append('Block', new Blob([block]), 'blob');
 
         await this.apiService.postBlockStream(url, token, formData, onProgress, signal);
     }

package/src/internal/upload/blockVerifier.ts

@@ -1,6 +1,6 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { UploadAPIService } from "./apiService";
-import { UploadCryptoService } from "./cryptoService";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { UploadAPIService } from './apiService';
+import { UploadCryptoService } from './cryptoService';
 
 export class BlockVerifier {
     private verificationCode?: Uint8Array;
@@ -20,18 +20,20 @@ export class BlockVerifier {
     async loadVerificationData() {
         const result = await this.apiService.getVerificationData(this.draftNodeRevisionUid);
         this.verificationCode = result.verificationCode;
-        this.contentKeyPacketSessionKey = await this.cryptoService.getContentKeyPacketSessionKey(this.nodeKey, result.base64ContentKeyPacket);
+        this.contentKeyPacketSessionKey = await this.cryptoService.getContentKeyPacketSessionKey(
+            this.nodeKey,
+            result.base64ContentKeyPacket,
+        );
     }
 
     async verifyBlock(encryptedBlock: Uint8Array): Promise<{
-        verificationToken: Uint8Array,
+        verificationToken: Uint8Array;
     }> {
         if (!this.verificationCode || !this.contentKeyPacketSessionKey) {
             throw new Error('Verifying block before loading verification data');
         }
 
         return this.cryptoService.verifyBlock(
-            this.nodeKey,
             this.contentKeyPacketSessionKey,
             this.verificationCode,
             encryptedBlock,

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

@@ -1,6 +1,6 @@
-import { ChunkStreamReader } from "./chunkStreamReader";
+import { ChunkStreamReader } from './chunkStreamReader';
 
-describe("ChunkStreamReader", () => {
+describe('ChunkStreamReader', () => {
     let stream: ReadableStream<Uint8Array>;
 
     beforeEach(() => {
@@ -15,7 +15,7 @@ describe("ChunkStreamReader", () => {
         });
     });
 
-    it("should yield chunks as enqueued if matching the size", async () => {
+    it('should yield chunks as enqueued if matching the size', async () => {
         const reader = new ChunkStreamReader(stream, 3);
 
         const chunks: Uint8Array[] = [];
@@ -30,7 +30,7 @@ describe("ChunkStreamReader", () => {
         expect(chunks[3]).toEqual(new Uint8Array([10, 11, 12]));
     });
 
-    it("should yield smaller chunks than enqueued chunks", async () => {
+    it('should yield smaller chunks than enqueued chunks', async () => {
         const reader = new ChunkStreamReader(stream, 2);
 
         const chunks: Uint8Array[] = [];
@@ -47,7 +47,7 @@ describe("ChunkStreamReader", () => {
         expect(chunks[5]).toEqual(new Uint8Array([11, 12]));
     });
 
-    it("should yield bigger chunks than enqueued chunks", async () => {
+    it('should yield bigger chunks than enqueued chunks', async () => {
         const reader = new ChunkStreamReader(stream, 4);
 
         const chunks: Uint8Array[] = [];
@@ -61,7 +61,7 @@ describe("ChunkStreamReader", () => {
         expect(chunks[2]).toEqual(new Uint8Array([9, 10, 11, 12]));
     });
 
-    it("should yield last incomplete chunk", async () => {
+    it('should yield last incomplete chunk', async () => {
         const reader = new ChunkStreamReader(stream, 5);
 
         const chunks: Uint8Array[] = [];
@@ -75,7 +75,7 @@ describe("ChunkStreamReader", () => {
         expect(chunks[2]).toEqual(new Uint8Array([11, 12]));
     });
 
-    it("should yield as one big chunk", async () => {
+    it('should yield as one big chunk', async () => {
         const reader = new ChunkStreamReader(stream, 100);
 
         const chunks: Uint8Array[] = [];

package/src/internal/upload/cryptoService.ts

@@ -1,9 +1,9 @@
-import { c } from "ttag";
+import { c } from 'ttag';
 
-import { DriveCrypto, PrivateKey, SessionKey } from "../../crypto";
-import { IntegrityError } from "../../errors";
-import { Thumbnail } from "../../interface";
-import { EncryptedBlock, EncryptedThumbnail, NodeCrypto, NodeRevisionDraftKeys, NodesService } from "./interface";
+import { DriveCrypto, PrivateKey, SessionKey } from '../../crypto';
+import { IntegrityError } from '../../errors';
+import { Thumbnail } from '../../interface';
+import { EncryptedBlock, EncryptedThumbnail, NodeCrypto, NodeRevisionDraftKeys, NodesService } from './interface';
 
 export class UploadCryptoService {
     constructor(
@@ -16,16 +16,12 @@ export class UploadCryptoService {
 
     async generateFileCrypto(
         parentUid: string,
-        parentKeys: { key: PrivateKey, hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
         name: string,
     ): Promise<NodeCrypto> {
         const signatureAddress = await this.nodesService.getRootNodeEmailKey(parentUid);
 
-        const [
-            nodeKeys,
-            { armoredNodeName },
-            hash,
-        ] = await Promise.all([
+        const [nodeKeys, { armoredNodeName }, hash] = await Promise.all([
             this.driveCrypto.generateKey([parentKeys.key], signatureAddress.addressKey),
             this.driveCrypto.encryptNodeName(name, undefined, parentKeys.key, signatureAddress.addressKey),
             this.driveCrypto.generateLookupHash(name, parentKeys.hashKey),
@@ -44,19 +40,24 @@ export class UploadCryptoService {
         };
     }
 
-    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string, hash: string }[]> {
-        return Promise.all(names.map(async (name) => ({
-            name,
-            hash: await this.driveCrypto.generateLookupHash(name, parentHashKey)
-        })));
+    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string; hash: string }[]> {
+        return Promise.all(
+            names.map(async (name) => ({
+                name,
+                hash: await this.driveCrypto.generateLookupHash(name, parentHashKey),
+            })),
+        );
     }
 
-    async encryptThumbnail(nodeRevisionDraftKeys: NodeRevisionDraftKeys, thumbnail: Thumbnail): Promise<EncryptedThumbnail> {
+    async encryptThumbnail(
+        nodeRevisionDraftKeys: NodeRevisionDraftKeys,
+        thumbnail: Thumbnail,
+    ): Promise<EncryptedThumbnail> {
         const { encryptedData } = await this.driveCrypto.encryptThumbnailBlock(
             thumbnail.thumbnail,
             nodeRevisionDraftKeys.contentKeyPacketSessionKey,
             nodeRevisionDraftKeys.signatureAddress.addressKey,
-        )
+        );
 
         const digest = await crypto.subtle.digest('SHA-256', encryptedData);
 
@@ -66,7 +67,7 @@ export class UploadCryptoService {
             originalSize: thumbnail.thumbnail.length,
             encryptedSize: encryptedData.length,
             hash: new Uint8Array(digest),
-        }
+        };
     }
 
     async encryptBlock(
@@ -93,25 +94,36 @@ export class UploadCryptoService {
             originalSize: block.length,
             encryptedSize: encryptedData.length,
             hash: new Uint8Array(digest),
-        }
+        };
     }
 
-    async commitFile(nodeRevisionDraftKeys: NodeRevisionDraftKeys, manifest: Uint8Array, extendedAttributes?: string): Promise<{
-        armoredManifestSignature: string,
-        signatureEmail: string,
-        armoredExtendedAttributes?: string,
+    async commitFile(
+        nodeRevisionDraftKeys: NodeRevisionDraftKeys,
+        manifest: Uint8Array,
+        extendedAttributes?: string,
+    ): Promise<{
+        armoredManifestSignature: string;
+        signatureEmail: string;
+        armoredExtendedAttributes?: string;
     }> {
-        const { armoredManifestSignature } = await this.driveCrypto.signManifest(manifest, nodeRevisionDraftKeys.signatureAddress.addressKey);
+        const { armoredManifestSignature } = await this.driveCrypto.signManifest(
+            manifest,
+            nodeRevisionDraftKeys.signatureAddress.addressKey,
+        );
 
         const { armoredExtendedAttributes } = extendedAttributes
-            ? await this.driveCrypto.encryptExtendedAttributes(extendedAttributes, nodeRevisionDraftKeys.key, nodeRevisionDraftKeys.signatureAddress.addressKey)
+            ? await this.driveCrypto.encryptExtendedAttributes(
+                  extendedAttributes,
+                  nodeRevisionDraftKeys.key,
+                  nodeRevisionDraftKeys.signatureAddress.addressKey,
+              )
             : { armoredExtendedAttributes: undefined };
 
         return {
             armoredManifestSignature,
             signatureEmail: nodeRevisionDraftKeys.signatureAddress.email,
             armoredExtendedAttributes,
-        }
+        };
     }
 
     async getContentKeyPacketSessionKey(nodeKey: PrivateKey, base64ContentKeyPacket: string): Promise<SessionKey> {
@@ -125,12 +137,11 @@ export class UploadCryptoService {
     }
 
     async verifyBlock(
-        nodeKey: PrivateKey,
         contentKeyPacketSessionKey: SessionKey,
         verificationCode: Uint8Array,
         encryptedData: Uint8Array,
     ): Promise<{
-        verificationToken: Uint8Array,
+        verificationToken: Uint8Array;
     }> {
         // Attempt to decrypt data block, to try to detect bitflips / bad hardware
         //
@@ -140,12 +151,7 @@ export class UploadCryptoService {
         // Additionally, we use the key provided by the verification endpoint, to
         // ensure the correct key was used to encrypt the data
         try {
-            await this.driveCrypto.decryptBlock(
-                encryptedData,
-                undefined,
-                nodeKey,
-                contentKeyPacketSessionKey,
-            );
+            await this.driveCrypto.decryptBlock(encryptedData, contentKeyPacketSessionKey);
         } catch (error) {
             throw new IntegrityError(c('Error').t`Data integrity check of one part failed`, {
                 error,
@@ -157,6 +163,6 @@ export class UploadCryptoService {
         const verificationToken = verificationCode.map((value, index) => value ^ (encryptedData[index] || 0));
         return {
             verificationToken,
-        }
+        };
     }
 }

package/src/internal/upload/digests.ts

@@ -1,4 +1,4 @@
-import { sha1 } from "@noble/hashes/legacy";
+import { sha1 } from '@noble/hashes/legacy';
 import { bytesToHex } from '@noble/hashes/utils';
 
 export class UploadDigests {
@@ -13,6 +13,6 @@ export class UploadDigests {
     digests(): { sha1: string } {
         return {
             sha1: bytesToHex(this.digestSha1.digest()),
-        }
+        };
     }
 }