@protontech/drive-sdk 0.9.8 → 0.10.0

package/src/internal/devices/manager.ts

@@ -23,6 +23,20 @@ export class DevicesManager {
         this.nodesManagementService = nodesManagementService;
     }
 
+    async getDevice(deviceUid: string): Promise<Device> {
+        const device = await this.getDeviceMetadata(deviceUid);
+
+        const [node] = await Array.fromAsync(this.nodesService.iterateNodes([device.rootFolderUid]));
+        if (!node || 'missingUid' in node) {
+            throw new ValidationError(c('Error').t`Device not found`);
+        }
+
+        return {
+            ...device,
+            name: node.name,
+        };
+    }
+
     async *iterateDevices(signal?: AbortSignal): AsyncGenerator<Device> {
         const devices = await this.apiService.getDevices(signal);
 

package/src/internal/download/apiService.ts

@@ -91,7 +91,7 @@ export class DownloadAPIService {
         token: string,
         onProgress?: (downloadedBytes: number) => void,
         signal?: AbortSignal,
-    ): Promise<Uint8Array> {
+    ): Promise<Uint8Array<ArrayBuffer>> {
         const rawBlockStream = await this.apiService.getBlockStream(baseUrl, token, signal);
         const progressStream = new ObserverStream((value) => {
             onProgress?.(value.length);

package/src/internal/download/cryptoService.ts

@@ -34,7 +34,7 @@ export class DownloadCryptoService {
         };
     }
 
-    async decryptBlock(encryptedBlock: Uint8Array, revisionKeys: RevisionKeys): Promise<Uint8Array> {
+    async decryptBlock(encryptedBlock: Uint8Array<ArrayBuffer>, revisionKeys: RevisionKeys): Promise<Uint8Array<ArrayBuffer>> {
         let decryptedBlock;
         try {
             // We do not verify signatures on blocks. We only verify
@@ -55,7 +55,7 @@ export class DownloadCryptoService {
         return decryptedBlock;
     }
 
-    async decryptThumbnail(thumbnail: Uint8Array, contentKeyPacketSessionKey: SessionKey): Promise<Uint8Array> {
+    async decryptThumbnail(thumbnail: Uint8Array<ArrayBuffer>, contentKeyPacketSessionKey: SessionKey): Promise<Uint8Array<ArrayBuffer>> {
         let decryptedBlock;
         try {
             const result = await this.driveCrypto.decryptThumbnailBlock(
@@ -72,7 +72,7 @@ export class DownloadCryptoService {
         return decryptedBlock;
     }
 
-    async verifyBlockIntegrity(encryptedBlock: Uint8Array, base64sha256Hash: string): Promise<void> {
+    async verifyBlockIntegrity(encryptedBlock: Uint8Array<ArrayBuffer>, base64sha256Hash: string): Promise<void> {
         const digest = await crypto.subtle.digest('SHA-256', encryptedBlock);
         const expectedHash = uint8ArrayToBase64String(new Uint8Array(digest));
 
@@ -87,7 +87,7 @@ export class DownloadCryptoService {
     async verifyManifest(
         revision: Revision,
         nodeKey: PrivateKey,
-        allBlockHashes: Uint8Array[],
+        allBlockHashes: Uint8Array<ArrayBuffer>[],
         armoredManifestSignature?: string,
     ): Promise<void> {
         const hash = mergeUint8Arrays(allBlockHashes);

package/src/internal/download/fileDownloader.test.ts

@@ -85,8 +85,8 @@ describe('FileDownloader', () => {
         let onFinish: () => void;
 
         let downloader: FileDownloader;
-        let writer: WritableStreamDefaultWriter<Uint8Array>;
-        let stream: WritableStream<Uint8Array>;
+        let writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>;
+        let stream: WritableStream<Uint8Array<ArrayBuffer>>;
 
         const verifySuccess = async (
             fileProgress: number = 6, // 3 blocks of length 1, 2, 3
@@ -360,8 +360,8 @@ describe('FileDownloader', () => {
         let onFinish: () => void;
 
         let downloader: FileDownloader;
-        let writer: WritableStreamDefaultWriter<Uint8Array>;
-        let stream: WritableStream<Uint8Array>;
+        let writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>;
+        let stream: WritableStream<Uint8Array<ArrayBuffer>>;
 
         beforeEach(() => {
             onProgress = jest.fn();

package/src/internal/download/fileDownloader.ts

@@ -30,7 +30,7 @@ export class FileDownloader {
         number,
         {
             downloadPromise: Promise<void>;
-            decryptedBufferedBlock?: Uint8Array;
+            decryptedBufferedBlock?: Uint8Array<ArrayBuffer>;
         }
     >();
 
@@ -120,7 +120,7 @@ export class FileDownloader {
         claimedBlockSizes: number[],
         position: number,
         cryptoKeys: RevisionKeys,
-    ): Promise<Uint8Array | Error | undefined> {
+    ): Promise<Uint8Array<ArrayBuffer> | Error | undefined> {
         const { value, done } = getBlockIndex(claimedBlockSizes, position);
         if (done) {
             return;
@@ -174,7 +174,7 @@ export class FileDownloader {
 
         // Collection of all block hashes for manifest verification.
         // This includes both thumbnail and regular blocks.
-        const allBlockHashes: Uint8Array[] = [];
+        const allBlockHashes: Uint8Array<ArrayBuffer>[] = [];
         let armoredManifestSignature: string | undefined;
 
         try {
@@ -271,12 +271,12 @@ export class FileDownloader {
         ignoreIntegrityErrors: boolean,
         cryptoKeys: RevisionKeys,
         onProgress?: (downloadedBytes: number) => void,
-    ): Promise<Uint8Array> {
+    ): Promise<Uint8Array<ArrayBuffer>> {
         const logger = new LoggerWithPrefix(this.logger, `block ${blockMetadata.index}`);
         logger.info(`Download started`);
 
         let blockProgress = 0;
-        let decryptedBlock: Uint8Array | null = null;
+        let decryptedBlock: Uint8Array<ArrayBuffer> | null = null;
         let retries = 0;
 
         while (!decryptedBlock) {
@@ -369,7 +369,7 @@ export class FileDownloader {
         }
     }
 
-    private async flushCompletedBlocks(write: (chunk: Uint8Array) => void | Promise<void>) {
+    private async flushCompletedBlocks(write: (chunk: Uint8Array<ArrayBuffer>) => void | Promise<void>) {
         this.logger.debug(`Flushing completed blocks`);
         while (this.isNextBlockDownloaded) {
             const decryptedBlock = this.ongoingDownloads.get(this.nextBlockIndex)!.decryptedBufferedBlock!;

package/src/internal/download/thumbnailDownloader.ts

@@ -24,7 +24,7 @@ export class ThumbnailDownloader {
     private batchThumbnailToNodeUids = new Map<string, string>();
     private ongoingDownloads = new Map<string, Promise<void>>();
     private bufferedThumbnails: (
-        | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+        | { nodeUid: string; ok: true; thumbnail: Uint8Array<ArrayBuffer> }
         | { nodeUid: string; ok: false; error: string }
     )[] = [];
 
@@ -163,7 +163,7 @@ export class ThumbnailDownloader {
     private async *iterateThumbnailDownloads(
         signal?: AbortSignal,
     ): AsyncGenerator<
-        | { nodeUid: string; ok: true; downloadPromise: Promise<Uint8Array> }
+        | { nodeUid: string; ok: true; downloadPromise: Promise<Uint8Array<ArrayBuffer>> }
         | { nodeUid: string; ok: false; error: string }
     > {
         const missingThumbnailUids = new Set(this.batchThumbnailToNodeUids.keys());
@@ -212,10 +212,10 @@ export class ThumbnailDownloader {
         bareUrl: string,
         token: string,
         signal?: AbortSignal,
-    ): Promise<Uint8Array> {
+    ): Promise<Uint8Array<ArrayBuffer>> {
         const logger = new LoggerWithPrefix(this.logger, `thumbnail ${token}`);
 
-        let decryptedBlock: Uint8Array | null = null;
+        let decryptedBlock: Uint8Array<ArrayBuffer> | null = null;
         let attempt = 0;
 
         while (!decryptedBlock) {

package/src/internal/nodes/cryptoService.test.ts

@@ -1,4 +1,4 @@
-import { DriveCrypto, PrivateKey, SessionKey, VERIFICATION_STATUS } from '../../crypto';
+import { DriveCrypto, PrivateKey, PublicKey, SessionKey, VERIFICATION_STATUS } from '../../crypto';
 import { MemberRole, ProtonDriveAccount, ProtonDriveTelemetry, RevisionState } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
 import {
@@ -20,7 +20,7 @@ describe('nodesCryptoService', () => {
 
     let cryptoService: NodesCryptoService;
 
-    const publicAddressKey = { _idx: 21312 };
+    const publicAddressKey = { _idx: 21312 } as PublicKey;
     const ownPrivateAddressKey = { id: 'id', key: 'key' as unknown as PrivateKey };
 
     beforeEach(() => {

package/src/internal/nodes/cryptoService.ts

@@ -145,7 +145,10 @@ export class NodesCryptoService {
                     }),
                     nameAuthor,
                     membership,
-                    activeRevision: 'file' in node.encryptedCrypto ? resultError(new Error(errorMessage)) : undefined,
+                    activeRevision:
+                        'file' in node.encryptedCrypto
+                            ? resultError(new Error(errorMessage, { cause: error }))
+                            : undefined,
                     folder: undefined,
                     errors: [error],
                 },
@@ -210,7 +213,7 @@ export class NodesCryptoService {
                 void this.reporter.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 const message = getErrorMessage(error);
                 const errorMessage = c('Error').t`Failed to decrypt active revision: ${message}`;
-                activeRevision = resultError(new Error(errorMessage));
+                activeRevision = resultError(new Error(errorMessage, { cause: error }));
             }
 
             try {
@@ -361,7 +364,7 @@ export class NodesCryptoService {
             void this.reporter.reportDecryptionError(node, 'nodeName', error);
             const errorMessage = getErrorMessage(error);
             return {
-                name: resultError(new Error(errorMessage)),
+                name: resultError(new Error(errorMessage, { cause: error })),
                 author: resultError({
                     claimedAuthor: getClaimedAuthor(nameSignatureEmail, verificationKeys.length === 0),
                     error: errorMessage,
@@ -433,7 +436,7 @@ export class NodesCryptoService {
         nodeKey: PrivateKey,
         addressKeys: PublicKey[],
     ): Promise<{
-        hashKey: Uint8Array;
+        hashKey: Uint8Array<ArrayBuffer>;
         author: Author;
     }> {
         if (!('folder' in node.encryptedCrypto)) {
@@ -583,7 +586,7 @@ export class NodesCryptoService {
     }
 
     async createFolder(
-        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,
         name: string,
         extendedAttributes?: string,
@@ -648,7 +651,7 @@ export class NodesCryptoService {
     }
 
     async encryptNewName(
-        parentKeys: { key: PrivateKey; hashKey?: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey?: Uint8Array<ArrayBuffer> },
         nodeNameSessionKey: SessionKey,
         signingKeys: NodeSigningKeys,
         newName: string,
@@ -684,7 +687,7 @@ export class NodesCryptoService {
     async encryptNodeWithNewParent(
         nodeName: DecryptedNode['name'],
         keys: { passphrase: string; passphraseSessionKey: SessionKey; nameSessionKey: SessionKey },
-        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,
     ): Promise<{
         encryptedName: string;
@@ -732,7 +735,7 @@ export class NodesCryptoService {
         };
     }
 
-    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string; hash: string }[]> {
+    async generateNameHashes(parentHashKey: Uint8Array<ArrayBuffer>, names: string[]): Promise<{ name: string; hash: string }[]> {
         return Promise.all(
             names.map(async (name) => ({
                 name,

package/src/internal/nodes/interface.ts

@@ -157,7 +157,7 @@ export interface DecryptedNodeKeys {
     key: PrivateKey;
     passphraseSessionKey: SessionKey;
     contentKeyPacketSessionKey?: SessionKey;
-    hashKey?: Uint8Array;
+    hashKey?: Uint8Array<ArrayBuffer>;
 }
 
 interface BaseRevision {

package/src/internal/nodes/nodesManagement.ts

@@ -180,7 +180,6 @@ export abstract class NodesManagementBase<
                 encryptedName: encryptedCrypto.encryptedName,
                 nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
                 hash: encryptedCrypto.hash,
-                // TODO: When moving photos, we need to pass content hash.
             },
         );
         const newNode: TDecryptedNode = {