@protontech/drive-sdk 0.6.0 → 0.6.2

package/src/interface/index.ts

@@ -3,6 +3,7 @@ import { OpenPGPCrypto, PrivateKey, SessionKey, SRPModule } from '../crypto';
 import { LatestEventIdProvider } from '../internal/events/interface';
 import { ProtonDriveAccount } from './account';
 import { ProtonDriveConfig } from './config';
+import { FeatureFlagProvider } from './featureFlags';
 import { ProtonDriveHTTPClient } from './httpClient';
 import { Telemetry, MetricEvent } from './telemetry';
 
@@ -12,6 +13,7 @@ export type { ProtonDriveAccount, ProtonDriveAccountAddress } from './account';
 export type { Author, UnverifiedAuthorError, AnonymousUser } from './author';
 export type { ProtonDriveConfig } from './config';
 export type { Device, DeviceOrUid } from './devices';
+export type { FeatureFlagProvider } from './featureFlags';
 export { DeviceType } from './devices';
 export type { FileDownloader, DownloadController, SeekableReadableStream } from './download';
 export type {
@@ -117,5 +119,6 @@ export interface ProtonDriveClientContructorParameters {
     srpModule: SRPModule;
     config?: ProtonDriveConfig;
     telemetry?: ProtonDriveTelemetry;
+    featureFlagProvider?: FeatureFlagProvider;
     latestEventIdProvider?: LatestEventIdProvider;
 }

package/src/internal/devices/interface.ts

@@ -13,7 +13,7 @@ export type DeviceMetadata = {
 };
 
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string }>;
     getMyFilesShareMemberEmailKey(): Promise<{
         addressId: string;
         email: string;

package/src/internal/devices/manager.test.ts

@@ -30,7 +30,7 @@ describe('DevicesManager', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn(),
+            getRootIDs: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {};
@@ -74,13 +74,13 @@ describe('DevicesManager', () => {
             shareId: 'shareid',
         } as DeviceMetadata;
 
-        sharesService.getOwnVolumeIDs.mockResolvedValue({ volumeId });
+        sharesService.getRootIDs.mockResolvedValue({ volumeId });
         cryptoService.createDevice.mockResolvedValue({ address, shareKey, node });
         apiService.createDevice.mockResolvedValue(createdDevice);
 
         const result = await manager.createDevice(name, deviceType);
 
-        expect(sharesService.getOwnVolumeIDs).toHaveBeenCalled();
+        expect(sharesService.getRootIDs).toHaveBeenCalled();
         expect(cryptoService.createDevice).toHaveBeenCalledWith(name);
         expect(apiService.createDevice).toHaveBeenCalledWith(
             { volumeId, type: deviceType },

package/src/internal/devices/manager.ts

@@ -47,7 +47,7 @@ export class DevicesManager {
     }
 
     async createDevice(name: string, deviceType: DeviceType): Promise<Device> {
-        const { volumeId } = await this.sharesService.getOwnVolumeIDs();
+        const { volumeId } = await this.sharesService.getRootIDs();
         const { address, shareKey, node } = await this.cryptoService.createDevice(name);
 
         const device = await this.apiService.createDevice(

package/src/internal/errors.test.ts

@@ -1,5 +1,6 @@
 import { VERIFICATION_STATUS } from '../crypto';
-import { getVerificationMessage } from './errors';
+import { AbortError, ConnectionError, RateLimitedError, ValidationError } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from './errors';
 
 describe('getVerificationMessage', () => {
     const testCases: [VERIFICATION_STATUS, Error[] | undefined, string | undefined, boolean, string][] = [
@@ -53,3 +54,63 @@ describe('getVerificationMessage', () => {
         });
     }
 });
+
+describe('isNotApplicationError', () => {
+    describe('SDK errors that should be ignored', () => {
+        it('returns true for AbortError', () => {
+            const error = new AbortError('Operation aborted');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for ValidationError', () => {
+            const error = new ValidationError('Validation failed');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for RateLimitedError', () => {
+            const error = new RateLimitedError('Rate limited');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for ConnectionError', () => {
+            const error = new ConnectionError('Connection failed');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+    });
+
+    describe('General errors with specific names that should be ignored', () => {
+        it('returns true for Error with name AbortError', () => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for Error with name OfflineError', () => {
+            const error = new Error('Offline');
+            error.name = 'OfflineError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for Error with name TimeoutError', () => {
+            const error = new Error('Timeout');
+            error.name = 'TimeoutError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+    });
+
+    describe('Errors that should not be ignored', () => {
+        it('returns false for regular Error', () => {
+            const error = new Error('Regular error');
+            expect(isNotApplicationError(error)).toBe(false);
+        });
+
+        it('returns false for undefined', () => {
+            expect(isNotApplicationError(undefined)).toBe(false);
+        });
+
+        it('returns false for non-Error object', () => {
+            const error = { message: 'Not an error' };
+            expect(isNotApplicationError(error)).toBe(false);
+        });
+    });
+});

package/src/internal/errors.ts

@@ -1,6 +1,7 @@
 import { c } from 'ttag';
 
 import { VERIFICATION_STATUS } from '../crypto';
+import { AbortError, ConnectionError, RateLimitedError, ValidationError } from '../errors';
 
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : c('Error').t`Unknown error`;
@@ -36,3 +37,29 @@ export function getVerificationMessage(
         ? c('Error').t`Signature verification for ${signatureType} failed`
         : c('Error').t`Signature verification failed`;
 }
+
+/**
+ * Returns true if the error is not an application error (it is for example
+ * a network error failing to fetch keys) and can be ignored for telemetry.
+ */
+export function isNotApplicationError(error?: unknown): boolean {
+    // SDK errors.
+    if (
+        error instanceof AbortError ||
+        error instanceof ValidationError ||
+        error instanceof RateLimitedError ||
+        error instanceof ConnectionError
+    ) {
+        return true;
+    }
+
+    // General errors that can come from the SDK dependencies (notably Account
+    // dependency which loads the keys for the crypto services).
+    if (error instanceof Error) {
+        if (error.name === 'AbortError' || error.name === 'OfflineError' || error.name === 'TimeoutError') {
+            return true;
+        }
+    }
+
+    return false;
+}

package/src/internal/nodes/cryptoReporter.ts

@@ -9,12 +9,9 @@ import {
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
 } from '../../interface';
-import { getVerificationMessage } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 import { splitNodeUid } from '../uids';
-import {
-    EncryptedNode,
-    SharesService,
-} from './interface';
+import { EncryptedNode, SharesService } from './interface';
 
 export class NodesCryptoReporter {
     private logger: Logger;
@@ -92,6 +89,10 @@ export class NodesCryptoReporter {
     }
 
     async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
+        if (isNotApplicationError(error)) {
+            return;
+        }
+
         if (this.reportedDecryptionErrors.has(node.uid)) {
             return;
         }

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

@@ -53,7 +53,7 @@ describe('nodesModules integration tests', () => {
         driveCrypto = {};
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
         };
 
         nodesModule = initNodesModule(

package/src/internal/nodes/interface.ts

@@ -177,7 +177,7 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

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

@@ -46,7 +46,7 @@ describe('nodesAccess', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -388,7 +388,7 @@ describe('nodesAccess', () => {
             const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
-                shareService.getOwnVolumeIDs = jest.fn().mockResolvedValue({ volumeId });
+                shareService.getRootIDs = jest.fn().mockResolvedValue({ volumeId });
                 apiService.iterateTrashedNodeUids = jest.fn().mockImplementation(async function* () {
                     yield node1.uid;
                     yield node2.uid;

package/src/internal/nodes/nodesAccess.ts

@@ -61,7 +61,7 @@ export class NodesAccess {
         private cryptoService: NodesCryptoService,
         private shareService: Pick<
             SharesService,
-            'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
+            'getRootIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
         >,
     ) {
         this.logger = telemetry.getLogger('nodes');
@@ -74,7 +74,7 @@ export class NodesAccess {
     }
 
     async getVolumeRootFolder() {
-        const { volumeId, rootNodeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId, rootNodeId } = await this.shareService.getRootIDs();
         const nodeUid = makeNodeUid(volumeId, rootNodeId);
         return this.getNode(nodeUid);
     }
@@ -154,7 +154,7 @@ export class NodesAccess {
 
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId } = await this.shareService.getRootIDs();
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.loadNodes(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
@@ -230,7 +230,7 @@ export class NodesAccess {
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
         this.debouncer.loadingNode(nodeUid);
         try {
-            const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+            const { volumeId: ownVolumeId } = await this.shareService.getRootIDs();
             const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
             return this.decryptNode(encryptedNode);
         } finally {
@@ -259,7 +259,7 @@ export class NodesAccess {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getRootIDs();
 
         const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
 

package/src/internal/photos/albums.ts

@@ -21,7 +21,7 @@ export class Albums {
     }
 
     async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+        const { volumeId } = await this.photoShares.getRootIDs();
 
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),

package/src/internal/photos/apiService.ts

@@ -18,6 +18,13 @@ type GetTimelineResponse =
 type GetAlbumsResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/albums']['get']['responses']['200']['content']['application/json'];
 
+type PostPhotoDuplicateRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostPhotoDuplicateResponse =
+    drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['responses']['200']['content']['application/json'];
+
 /**
  * Provides API communication for fetching and manipulating photos and albums
  * metadata.
@@ -148,4 +155,37 @@ export class PhotosAPIService {
             anchor = response.AnchorID;
         }
     }
+
+    async checkPhotoDuplicates(
+        volumeId: string,
+        nameHashes: string[],
+        signal?: AbortSignal,
+    ): Promise<
+        {
+            nameHash: string;
+            contentHash: string;
+            nodeUid: string;
+            clientUid?: string;
+        }[]
+    > {
+        const response = await this.apiService.post<PostPhotoDuplicateRequest, PostPhotoDuplicateResponse>(
+            `drive/volumes/${volumeId}/photos/duplicates`,
+            {
+                NameHashes: nameHashes,
+            },
+            signal,
+        );
+
+        return response.DuplicateHashes.map((duplicate) => {
+            if (!duplicate.Hash || !duplicate.ContentHash || duplicate.LinkState !== 1 /* Active */) {
+                return undefined;
+            }
+            return {
+                nameHash: duplicate.Hash,
+                contentHash: duplicate.ContentHash,
+                nodeUid: makeNodeUid(volumeId, duplicate.LinkID),
+                clientUid: duplicate.ClientUID || undefined,
+            };
+        }).filter((duplicate) => duplicate !== undefined);
+    }
 }

package/src/internal/photos/index.ts

@@ -36,12 +36,20 @@ export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType
  * including API communication, crypto, caching, and event handling.
  */
 export function initPhotosModule(
+    telemetry: ProtonDriveTelemetry,
     apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
     photoShares: PhotoSharesManager,
     nodesService: NodesService,
 ) {
     const api = new PhotosAPIService(apiService);
-    const timeline = new PhotosTimeline(api, photoShares);
+    const timeline = new PhotosTimeline(
+        telemetry.getLogger('photos-timeline'),
+        api,
+        driveCrypto,
+        photoShares,
+        nodesService,
+    );
     const albums = new Albums(api, photoShares, nodesService);
 
     return {

package/src/internal/photos/interface.ts

@@ -4,7 +4,7 @@ import { DecryptedNode } from '../nodes';
 import { EncryptedShare } from '../shares';
 
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
@@ -26,4 +26,7 @@ export interface SharesService {
 export interface NodesService {
     getNode(nodeUid: string): Promise<DecryptedNode>;
     iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
+    getNodeKeys(nodeUid: string): Promise<{
+        hashKey?: Uint8Array;
+    }>;
 }

package/src/internal/photos/shares.ts

@@ -34,7 +34,7 @@ export class PhotoSharesManager {
         this.sharesService = sharesService;
     }
 
-    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
+    async getRootIDs(): Promise<VolumeShareNodeIDs> {
         if (this.photoRootIds) {
             return this.photoRootIds;
         }
@@ -113,7 +113,7 @@ export class PhotoSharesManager {
     }
 
     async isOwnVolume(volumeId: string): Promise<boolean> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
         if (volumeId === myVolumeId) {
             return true;
         }
@@ -121,7 +121,7 @@ export class PhotoSharesManager {
     }
 
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
         if (volumeId === myVolumeId) {
             return MetricVolumeType.OwnVolume;
         }

package/src/internal/photos/timeline.test.ts

@@ -0,0 +1,116 @@
+import { getMockLogger } from '../../tests/logger';
+import { DriveCrypto } from '../../crypto';
+import { makeNodeUid } from '../uids';
+import { PhotosAPIService } from './apiService';
+import { NodesService } from './interface';
+import { PhotoSharesManager } from './shares';
+import { PhotosTimeline } from './timeline';
+
+describe('PhotosTimeline', () => {
+    let logger: ReturnType<typeof getMockLogger>;
+    let apiService: PhotosAPIService;
+    let driveCrypto: DriveCrypto;
+    let photoShares: PhotoSharesManager;
+    let nodesService: NodesService;
+    let timeline: PhotosTimeline;
+
+    const volumeId = 'volumeId';
+    const rootNodeId = 'rootNodeId';
+    const rootNodeUid = makeNodeUid(volumeId, rootNodeId);
+    const hashKey = new Uint8Array([1, 2, 3]);
+    const name = 'photo.jpg';
+    const nameHash = 'nameHash123';
+    const sha1 = 'sha1Hash123';
+    const contentHash = 'contentHash123';
+
+    beforeEach(() => {
+        logger = getMockLogger();
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            checkPhotoDuplicates: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        driveCrypto = {
+            generateLookupHash: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        photoShares = {
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId, rootNodeId }),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesService = {
+            getNodeKeys: jest.fn().mockResolvedValue({ hashKey }),
+        };
+
+        timeline = new PhotosTimeline(logger, apiService, driveCrypto, photoShares, nodesService);
+    });
+
+    describe('isDuplicatePhoto', () => {
+        it('should not call sha1 callback when there is no name hash match', async () => {
+            const generateSha1 = jest.fn();
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue([]);
+            driveCrypto.generateLookupHash = jest.fn().mockResolvedValue(nameHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(false);
+            expect(generateSha1).not.toHaveBeenCalled();
+            expect(photoShares.getRootIDs).toHaveBeenCalled();
+            expect(nodesService.getNodeKeys).toHaveBeenCalledWith(rootNodeUid);
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledWith(name, hashKey);
+            expect(apiService.checkPhotoDuplicates).toHaveBeenCalledWith(volumeId, [nameHash], undefined);
+        });
+
+        it('should call sha1 callback and not logger when name hash match but content hash does not', async () => {
+            const generateSha1 = jest.fn().mockResolvedValue(sha1);
+            const duplicates = [
+                {
+                    nameHash: nameHash,
+                    contentHash: 'differentContentHash',
+                    nodeUid: 'volumeId~node1',
+                },
+            ];
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue(duplicates);
+            driveCrypto.generateLookupHash = jest
+                .fn()
+                .mockResolvedValueOnce(nameHash)
+                .mockResolvedValueOnce(contentHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(false);
+            expect(generateSha1).toHaveBeenCalledTimes(1);
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledTimes(2);
+            expect(driveCrypto.generateLookupHash).toHaveBeenNthCalledWith(1, name, hashKey);
+            expect(driveCrypto.generateLookupHash).toHaveBeenNthCalledWith(2, sha1, hashKey);
+            expect(logger.debug).not.toHaveBeenCalled();
+        });
+
+        it('should call sha1 and logger when name and content hashes match', async () => {
+            const generateSha1 = jest.fn().mockResolvedValue(sha1);
+            const nodeUid1 = 'volumeId~node1';
+            const duplicates = [
+                {
+                    nameHash: nameHash,
+                    contentHash: contentHash,
+                    nodeUid: nodeUid1,
+                },
+            ];
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue(duplicates);
+            driveCrypto.generateLookupHash = jest
+                .fn()
+                .mockResolvedValueOnce(nameHash)
+                .mockResolvedValueOnce(contentHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(true);
+            expect(generateSha1).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledWith(
+                `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUid1}`,
+            );
+        });
+    });
+});
+

package/src/internal/photos/timeline.ts

@@ -1,4 +1,8 @@
+import { DriveCrypto } from '../../crypto';
+import { Logger } from '../../interface';
+import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
+import { NodesService } from './interface';
 import { PhotoSharesManager } from './shares';
 
 /**
@@ -6,19 +10,60 @@ import { PhotoSharesManager } from './shares';
  */
 export class PhotosTimeline {
     constructor(
+        private logger: Logger,
         private apiService: PhotosAPIService,
+        private driveCrypto: DriveCrypto,
         private photoShares: PhotoSharesManager,
+        private nodesService: NodesService,
     ) {
+        this.logger = logger;
         this.apiService = apiService;
+        this.driveCrypto = driveCrypto;
         this.photoShares = photoShares;
+        this.nodesService = nodesService;
     }
 
-    async* iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
         nodeUid: string;
         captureTime: Date;
         tags: number[];
     }> {
-        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+        const { volumeId } = await this.photoShares.getRootIDs();
         yield* this.apiService.iterateTimeline(volumeId, signal);
     }
+
+    async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
+        const { volumeId, rootNodeId } = await this.photoShares.getRootIDs();
+        const rootNodeUid = makeNodeUid(volumeId, rootNodeId);
+        const { hashKey } = await this.nodesService.getNodeKeys(rootNodeUid);
+        if (!hashKey) {
+            throw new Error('Hash key of photo root node not found');
+        }
+
+        const nameHash = await this.driveCrypto.generateLookupHash(name, hashKey);
+        const duplicates = await this.apiService.checkPhotoDuplicates(volumeId, [nameHash], signal);
+
+        if (duplicates.length === 0) {
+            return false;
+        }
+
+        // Generate the SHA1 only when there is any matching node hash to avoid
+        // computing it for every node as in most cases there is no match.
+        const sha1 = await generateSha1();
+        const contentHash = await this.driveCrypto.generateLookupHash(sha1, hashKey);
+
+        const matchingDuplicates = duplicates.filter(
+            (duplicate) => duplicate.nameHash === nameHash && duplicate.contentHash === contentHash,
+        );
+
+        if (matchingDuplicates.length === 0) {
+            return false;
+        }
+
+        const nodeUids = matchingDuplicates.map((duplicate) => duplicate.nodeUid);
+        this.logger.debug(
+            `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUids}`,
+        );
+        return true;
+    }
 }

package/src/internal/photos/upload.ts

@@ -220,7 +220,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             XAttr: options.armoredExtendedAttributes || null,
             Photo: {
                 ContentHash: photo.contentHash,
-                CaptureTime: photo.captureTime?.getTime() || 0,
+                CaptureTime: photo.captureTime ? Math.floor(photo.captureTime?.getTime() /1000) : 0,
                 MainPhotoLinkID: photo.mainPhotoLinkID || null,
                 Tags: photo.tags || [],
                 Exif: null, // Deprecated field, not used.

package/src/internal/shares/cryptoService.ts

@@ -9,7 +9,7 @@ import {
     MetricVolumeType,
 } from '../../interface';
 import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 import {
     EncryptedRootShare,
     DecryptedRootShare,
@@ -119,6 +119,10 @@ export class SharesCryptoService {
     }
 
     private reportDecryptionError(share: EncryptedRootShare, error?: unknown) {
+        if (isNotApplicationError(error)) {
+            return;
+        }
+
         if (this.reportedDecryptionErrors.has(share.shareId)) {
             return;
         }