@protontech/drive-sdk 0.14.9 → 0.15.0

package/src/internal/photos/albumsManager.ts

@@ -220,7 +220,11 @@ export class AlbumsManager {
             this.logger,
             signal,
         );
-        yield* process.execute(photoNodeUids);
+        try {
+            yield* process.execute(photoNodeUids);
+        } finally {
+            await this.nodesService.notifyNodeChanged(albumNodeUid);
+        }
     }
 
     async *removePhotos(
@@ -228,11 +232,15 @@ export class AlbumsManager {
         photoNodeUids: string[],
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResultWithError> {
-        for await (const result of this.apiService.removePhotosFromAlbum(albumNodeUid, photoNodeUids, signal)) {
-            if (result.ok) {
-                await this.nodesService.notifyNodeChanged(result.uid);
+        try {
+            for await (const result of this.apiService.removePhotosFromAlbum(albumNodeUid, photoNodeUids, signal)) {
+                if (result.ok) {
+                    await this.nodesService.notifyNodeChanged(result.uid);
+                }
+                yield result;
             }
-            yield result;
+        } finally {
+            await this.nodesService.notifyNodeChanged(albumNodeUid);
         }
     }
 

package/src/internal/photos/apiService.ts

@@ -494,7 +494,7 @@ export class PhotosAPIService {
     ): AsyncGenerator<NodeResultWithError> {
         const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
 
-        const batchSize = 50;
+        const batchSize = 10;
 
         for (const photoNodeUidsBatch of batch(photoNodeUids, batchSize)) {
             const linkIds = photoNodeUidsBatch.map((nodeUid) => splitNodeUid(nodeUid).nodeId);

package/src/internal/photos/index.ts

@@ -7,9 +7,9 @@ import {
     ProtonDriveTelemetry,
 } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { NodesCryptoService } from '../nodes/cryptoService';
-import { NodesCryptoReporter } from '../nodes/cryptoReporter';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { NodesCryptoReporter } from '../nodes/cryptoReporter';
+import { NodesCryptoService } from '../nodes/cryptoService';
 import { NodesEventsHandler } from '../nodes/events';
 import { NodesRevisons } from '../nodes/nodesRevisions';
 import { ShareTargetType } from '../shares';
@@ -17,16 +17,16 @@ import { SharesCache } from '../shares/cache';
 import { SharesCryptoCache } from '../shares/cryptoCache';
 import { SharesCryptoService } from '../shares/cryptoService';
 import { NodesService as UploadNodesService } from '../upload/interface';
-import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
-import { AlbumsManager } from './albumsManager';
+import { UploadTelemetry } from '../upload/telemetry';
 import { AlbumsCryptoService } from './albumsCrypto';
+import { AlbumsManager } from './albumsManager';
 import { PhotosAPIService } from './apiService';
 import { SharesService } from './interface';
-import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
+import { PhotosNodesAccess, PhotosNodesAPIService, PhotosNodesCache, PhotosNodesManagement } from './nodes';
+import { PhotosManager } from './photosManager';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
-import { PhotosManager } from './photosManager';
 import {
     PhotoFileUploader,
     PhotoUploadAPIService,
@@ -35,7 +35,7 @@ import {
     PhotoUploadMetadata,
 } from './upload';
 
-export type { DecryptedPhotoNode, TimelineItem, AlbumItem } from './interface';
+export type { AlbumItem, DecryptedPhotoNode, TimelineItem } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];

package/src/internal/photos/interface.ts

@@ -1,6 +1,6 @@
 import { PrivateKey } from '../../crypto';
-import { MetricVolumeType, PhotoAttributes, AlbumAttributes, PhotoTag } from '../../interface';
-import { DecryptedNode, EncryptedNode, DecryptedUnparsedNode } from '../nodes/interface';
+import { AlbumAttributes, MetricVolumeType, PhotoAttributes, PhotoTag } from '../../interface';
+import { DecryptedNode, DecryptedUnparsedNode, EncryptedNode } from '../nodes/interface';
 import { EncryptedShare } from '../shares';
 
 export interface SharesService {

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

@@ -1,10 +1,10 @@
 import { MemoryCache } from '../../cache';
-import { NodeType, MemberRole } from '../../interface';
+import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { getMockTelemetry } from '../../tests/telemetry';
 import { DriveAPIService } from '../apiService';
 import { DecryptedPhotoNode } from './interface';
-import { PhotosNodesAPIService, PhotosNodesCache, PhotosNodesAccess, PhotosNodesCryptoService } from './nodes';
+import { PhotosNodesAccess, PhotosNodesAPIService, PhotosNodesCache, PhotosNodesCryptoService } from './nodes';
 
 function generateAPINode() {
     return {
@@ -55,7 +55,7 @@ function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
     };
 }
 
-function generateAPIPhotoNode(linkOverrides = {}, overrides = {}) {
+function generateAPIPhotoNode(linkOverrides = {}, photoOverrides = {}, overrides = {}) {
     const node = generateAPINode();
     return {
         ...node,
@@ -84,6 +84,7 @@ function generateAPIPhotoNode(linkOverrides = {}, overrides = {}) {
             MediaType: 'image/jpeg',
             ContentKeyPacket: 'contentKeyPacket',
             ContentKeyPacketSignature: 'contentKeyPacketSig',
+            ...photoOverrides,
         },
         Folder: null,
         ...overrides,
@@ -103,12 +104,16 @@ describe('PhotosNodesAPIService', () => {
     });
 
     describe('linkToEncryptedNode', () => {
-        async function testIterateNodes(mockedLink: object, expectedType: NodeType) {
+        async function testIterateNodes(mockedLink: object, expectedType?: NodeType) {
             apiMock.post = jest.fn().mockResolvedValue({ Links: [mockedLink] });
 
             const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
-            expect(nodes).toHaveLength(1);
-            expect(nodes[0].type).toBe(expectedType);
+            if (expectedType) {
+                expect(nodes).toHaveLength(1);
+                expect(nodes[0].type).toBe(expectedType);
+            } else {
+                expect(nodes).toHaveLength(0);
+            }
 
             return nodes;
         }
@@ -136,6 +141,17 @@ describe('PhotosNodesAPIService', () => {
             expect(nodes[0].photo?.albums[0].nodeUid).toBe('volumeId~albumLinkId1');
             expect(nodes[0].photo?.albums[0].additionTime).toEqual(new Date(1700001000 * 1000));
         });
+
+        it('should handle photo node with null capture time', async () => {
+            await testIterateNodes(generateAPIPhotoNode({}, { CaptureTime: null }), undefined);
+        });
+
+        it('should handle photo node with capture time set to zero', async () => {
+            const nodes = await testIterateNodes(generateAPIPhotoNode({}, { CaptureTime: 0 }), NodeType.Photo);
+
+            expect(nodes[0].photo).toBeDefined();
+            expect(nodes[0].photo?.captureTime).toEqual(new Date(0));
+        });
     });
 });
 

package/src/internal/photos/nodes.ts

@@ -2,14 +2,14 @@ import { PrivateKey } from '../../crypto';
 import { DecryptionError } from '../../errors';
 import { NodeType } from '../../interface';
 import { drivePaths } from '../apiService';
-import { NodeAPIServiceBase, linkToEncryptedNode, linkToEncryptedNodeBaseMetadata } from '../nodes/apiService';
-import { NodesCacheBase, serialiseNode, deserialiseNode } from '../nodes/cache';
+import { linkToEncryptedNode, linkToEncryptedNodeBaseMetadata, NodeAPIServiceBase } from '../nodes/apiService';
+import { deserialiseNode, NodesCacheBase, serialiseNode } from '../nodes/cache';
 import { NodesCryptoService } from '../nodes/cryptoService';
 import { DecryptedNodeKeys } from '../nodes/interface';
 import { NodesAccessBase, parseNode as parseNodeBase } from '../nodes/nodesAccess';
 import { NodesManagementBase } from '../nodes/nodesManagement';
 import { makeNodeUid } from '../uids';
-import { EncryptedPhotoNode, DecryptedPhotoNode, DecryptedUnparsedPhotoNode } from './interface';
+import { DecryptedPhotoNode, DecryptedUnparsedPhotoNode, EncryptedPhotoNode } from './interface';
 
 type PostLoadLinksMetadataRequest = Extract<
     drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['requestBody'],
@@ -18,10 +18,7 @@ type PostLoadLinksMetadataRequest = Extract<
 type PostLoadLinksMetadataResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
 
-export class PhotosNodesAPIService extends NodeAPIServiceBase<
-    EncryptedPhotoNode,
-    PostLoadLinksMetadataResponse['Links'][0]
-> {
+export class PhotosNodesAPIService extends NodeAPIServiceBase<EncryptedPhotoNode, PostLoadLinksMetadataResponse['Links'][0]> {
     protected async fetchNodeMetadata(volumeId: string, linkIds: string[], signal?: AbortSignal) {
         const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
             `drive/photos/volumes/${volumeId}/links`,
@@ -37,7 +34,7 @@ export class PhotosNodesAPIService extends NodeAPIServiceBase<
         volumeId: string,
         link: PostLoadLinksMetadataResponse['Links'][0],
         isOwnVolumeId: boolean,
-    ): EncryptedPhotoNode {
+    ): EncryptedPhotoNode | undefined {
         const { baseNodeMetadata, baseCryptoNodeMetadata } = linkToEncryptedNodeBaseMetadata(
             this.logger,
             volumeId,
@@ -45,13 +42,23 @@ export class PhotosNodesAPIService extends NodeAPIServiceBase<
             isOwnVolumeId,
         );
 
-        if (link.Link.Type === 2 && link.Photo && link.Photo.ActiveRevision) {
+        if (link.Link.Type === 2 && link.Photo) {
             const node = linkToEncryptedNode(
                 this.logger,
                 volumeId,
                 { ...link, File: link.Photo, Folder: null },
                 isOwnVolumeId,
             );
+            if (!node) {
+                return undefined;
+            }
+            // Capture time is not present only for draft nodes.
+            // Draft nodes are not exposed to the client and are internal to
+            // upload module only.
+            if (link.Photo.CaptureTime === null || link.Photo.CaptureTime === undefined) {
+                this.logger.warn(`Requested draft photo node, skipping from the result`);
+                return undefined;
+            }
             return {
                 ...node,
                 type: NodeType.Photo,

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

@@ -1,11 +1,11 @@
-import { resultOk, PhotoTag } from '../../interface';
+import { PhotoTag, resultOk } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
-import { PhotosManager, UpdatePhotoSettings } from './photosManager';
-import { PhotosAPIService } from './apiService';
 import { AlbumsCryptoService } from './albumsCrypto';
-import { PhotosNodesAccess } from './nodes';
-import { DecryptedPhotoNode } from './interface';
+import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
+import { DecryptedPhotoNode } from './interface';
+import { PhotosNodesAccess } from './nodes';
+import { PhotosManager, UpdatePhotoSettings } from './photosManager';
 
 function createMockPhotoNode(uid: string, overrides: Partial<DecryptedPhotoNode> = {}): DecryptedPhotoNode {
     return {

package/src/internal/photos/photosManager.ts

@@ -3,12 +3,12 @@ import { c } from 'ttag';
 import { AbortError } from '../../errors';
 import { Logger, NodeResultWithError, PhotoTag } from '../../interface';
 import { batch } from '../batch';
-import { PhotosAPIService } from './apiService';
-import { PhotoAlreadyInTargetError, PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
-import { PhotosNodesAccess } from './nodes';
-import { AlbumsCryptoService } from './albumsCrypto';
 import { createBatches } from './addToAlbum';
+import { AlbumsCryptoService } from './albumsCrypto';
+import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
+import { PhotosNodesAccess } from './nodes';
+import { PhotoAlreadyInTargetError, PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 
 /**
  * The number of photos that are loaded in parallel to prepare the payloads.

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

@@ -2,8 +2,8 @@ import { ValidationError } from '../../errors';
 import { resultOk } from '../../interface';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { DecryptedPhotoNode } from './interface';
-import { PhotoTransferPayloadBuilder } from './photosTransferPayloadBuilder';
 import { PhotosNodesAccess } from './nodes';
+import { PhotoTransferPayloadBuilder } from './photosTransferPayloadBuilder';
 
 /**
  * Helper to create a mock photo node with minimal required properties.

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

@@ -1,5 +1,5 @@
-import { getMockLogger } from '../../tests/logger';
 import { DriveCrypto } from '../../crypto';
+import { getMockLogger } from '../../tests/logger';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
 import { PhotosNodesAccess } from './nodes';

package/src/internal/photos/upload.ts

@@ -1,11 +1,11 @@
 import { DriveCrypto } from '../../crypto';
 import {
-    ProtonDriveTelemetry,
-    UploadMetadata,
-    Thumbnail,
     AnonymousUser,
     FeatureFlagProvider,
     PhotoTag,
+    ProtonDriveTelemetry,
+    Thumbnail,
+    UploadMetadata,
 } from '../../interface';
 import { DriveAPIService, drivePaths } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';

package/src/internal/sdkEvents.ts

@@ -1,4 +1,4 @@
-import { ProtonDriveTelemetry, Logger, SDKEvent } from '../interface';
+import { Logger, ProtonDriveTelemetry, SDKEvent } from '../interface';
 
 export class SDKEvents {
     private logger: Logger;

package/src/internal/shares/apiService.ts

@@ -1,6 +1,6 @@
 import { DriveAPIService, drivePaths } from '../apiService';
 import { makeMemberUid } from '../uids';
-import { EncryptedShare, EncryptedRootShare, EncryptedShareCrypto, ShareType } from './interface';
+import { EncryptedRootShare, EncryptedShare, EncryptedShareCrypto, ShareType } from './interface';
 
 type PostCreateVolumeRequest = Extract<
     drivePaths['/drive/volumes']['post']['requestBody'],

package/src/internal/shares/cache.ts

@@ -1,4 +1,4 @@
-import { ProtonDriveEntitiesCache, Logger } from '../../interface';
+import { Logger, ProtonDriveEntitiesCache } from '../../interface';
 import { getErrorMessage } from '../errors';
 import { Volume } from './interface';
 

package/src/internal/shares/cryptoCache.test.ts

@@ -1,5 +1,5 @@
-import { PrivateKey, SessionKey } from '../../crypto';
 import { MemoryCache } from '../../cache';
+import { PrivateKey, SessionKey } from '../../crypto';
 import { CachedCryptoMaterial } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { SharesCryptoCache } from './cryptoCache';

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

@@ -1,8 +1,8 @@
 import { DriveCrypto, PrivateKey, SessionKey, VERIFICATION_STATUS } from '../../crypto';
 import { ProtonDriveAccount, ProtonDriveTelemetry } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
-import { EncryptedRootShare, ShareType } from './interface';
 import { SharesCryptoService } from './cryptoService';
+import { EncryptedRootShare, ShareType } from './interface';
 
 describe('SharesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;

package/src/internal/shares/cryptoService.ts

@@ -1,20 +1,20 @@
+import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
 import {
+    Logger,
+    MetricVolumeType,
     ProtonDriveAccount,
-    resultOk,
-    resultError,
+    ProtonDriveTelemetry,
     Result,
+    resultError,
+    resultOk,
     UnverifiedAuthorError,
-    ProtonDriveTelemetry,
-    Logger,
-    MetricVolumeType,
 } from '../../interface';
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
 import { getVerificationMessage, isNotApplicationError } from '../errors';
 import {
-    EncryptedRootShare,
     DecryptedRootShare,
-    EncryptedShareCrypto,
     DecryptedShareKey,
+    EncryptedRootShare,
+    EncryptedShareCrypto,
     ShareType,
 } from './interface';
 

package/src/internal/shares/index.ts

@@ -1,19 +1,19 @@
+import { DriveCrypto } from '../../crypto';
 import {
-    ProtonDriveEntitiesCache,
-    ProtonDriveCryptoCache,
     ProtonDriveAccount,
+    ProtonDriveCryptoCache,
+    ProtonDriveEntitiesCache,
     ProtonDriveTelemetry,
 } from '../../interface';
-import { DriveCrypto } from '../../crypto';
 import { DriveAPIService } from '../apiService';
 import { SharesAPIService } from './apiService';
-import { SharesCryptoCache } from './cryptoCache';
 import { SharesCache } from './cache';
+import { SharesCryptoCache } from './cryptoCache';
 import { SharesCryptoService } from './cryptoService';
 import { SharesManager } from './manager';
 
-export { ShareTargetType } from './interface';
 export type { EncryptedShare } from './interface';
+export { ShareTargetType } from './interface';
 
 /**
  * Provides facade for the whole shares module.

package/src/internal/shares/manager.ts

@@ -1,11 +1,11 @@
-import { Logger, MetricVolumeType, ProtonDriveAccount } from '../../interface';
 import { PrivateKey } from '../../crypto';
+import { Logger, MetricVolumeType, ProtonDriveAccount } from '../../interface';
 import { NotFoundAPIError } from '../apiService';
 import { SharesAPIService } from './apiService';
 import { SharesCache } from './cache';
 import { SharesCryptoCache } from './cryptoCache';
 import { SharesCryptoService } from './cryptoService';
-import { VolumeShareNodeIDs, EncryptedShare, EncryptedRootShare } from './interface';
+import { EncryptedRootShare, EncryptedShare, VolumeShareNodeIDs } from './interface';
 
 /**
  * Provides high-level actions for managing shares.

package/src/internal/sharing/apiService.ts

@@ -1,31 +1,31 @@
 import { SRPVerifier } from '../../crypto';
-import { MemberRole, NonProtonInvitationState, Logger } from '../../interface';
+import { Logger, MemberRole, NonProtonInvitationState } from '../../interface';
 import {
     DriveAPIService,
     drivePaths,
+    memberRoleToPermission,
     nodeTypeNumberToNodeType,
     permissionsToMemberRole,
-    memberRoleToPermission,
 } from '../apiService';
 import { ShareTargetType } from '../shares';
 import {
-    makeNodeUid,
-    splitNodeUid,
     makeInvitationUid,
-    splitInvitationUid,
     makeMemberUid,
-    splitMemberUid,
+    makeNodeUid,
     makePublicLinkUid,
+    splitInvitationUid,
+    splitMemberUid,
+    splitNodeUid,
     splitPublicLinkUid,
 } from '../uids';
 import {
-    EncryptedInvitationRequest,
+    EncryptedBookmark,
+    EncryptedExternalInvitation,
+    EncryptedExternalInvitationRequest,
     EncryptedInvitation,
+    EncryptedInvitationRequest,
     EncryptedInvitationWithNode,
-    EncryptedExternalInvitation,
     EncryptedMember,
-    EncryptedBookmark,
-    EncryptedExternalInvitationRequest,
     EncryptedPublicLink,
     EncryptedPublicLinkCrypto,
 } from './interface';

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

@@ -8,8 +8,8 @@ import {
     resultOk,
 } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
-import { SharesService } from './interface';
 import { PUBLIC_LINK_GENERATED_PASSWORD_LENGTH, SharingCryptoService } from './cryptoService';
+import { SharesService } from './interface';
 
 describe('SharingCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;

package/src/internal/sharing/cryptoService.ts

@@ -1,4 +1,3 @@
-import bcrypt from 'bcryptjs';
 import { c } from 'ttag';
 
 import {
@@ -6,42 +5,37 @@ import {
     PrivateKey,
     SessionKey,
     SRPVerifier,
-    uint8ArrayToBase64String,
     VERIFICATION_STATUS,
 } from '../../crypto';
+import { DecryptionError } from '../../errors';
 import {
+    Author,
+    InvalidNameError,
+    Member,
+    MetricVolumeType,
+    NonProtonInvitation,
     ProtonDriveAccount,
+    ProtonDriveTelemetry,
     ProtonInvitation,
     ProtonInvitationWithNode,
-    NonProtonInvitation,
-    Author,
     Result,
-    Member,
-    UnverifiedAuthorError,
     resultError,
     resultOk,
-    InvalidNameError,
-    ProtonDriveTelemetry,
-    MetricVolumeType,
+    UnverifiedAuthorError,
 } from '../../interface';
-import { validateNodeName } from '../nodes/validations';
 import { getErrorMessage, getVerificationMessage } from '../errors';
+import { validateNodeName } from '../nodes/validations';
 import { EncryptedShare } from '../shares';
 import {
+    EncryptedBookmark,
+    EncryptedExternalInvitation,
     EncryptedInvitation,
     EncryptedInvitationWithNode,
-    EncryptedExternalInvitation,
     EncryptedMember,
     EncryptedPublicLink,
     PublicLinkWithCreatorEmail,
-    EncryptedBookmark,
     SharesService,
 } from './interface';
-import { DecryptionError } from '../../errors';
-
-// Version 2 of bcrypt with 2**10 rounds.
-// https://en.wikipedia.org/wiki/Bcrypt#Description
-const BCRYPT_PREFIX = '$2y$10$';
 
 export const PUBLIC_LINK_GENERATED_PASSWORD_LENGTH = 12;
 
@@ -325,13 +319,10 @@ export class SharingCryptoService {
         const address = await this.account.getOwnAddress(creatorEmail);
         const addressKey = address.keys[address.primaryKeyIndex].key;
 
-        const { base64Salt: base64SharePasswordSalt, bcryptPassphrase } =
-            await this.computeKeySaltAndPassphrase(password);
-        const { base64SharePassphraseKeyPacket, armoredPassword, srp } =
+        const { base64SharePasswordSalt, base64SharePassphraseKeyPacket, armoredPassword, srp } =
             await this.driveCrypto.encryptPublicLinkPasswordAndSessionKey(
                 password,
                 addressKey,
-                bcryptPassphrase,
                 shareSessionKey,
             );
 
@@ -357,22 +348,6 @@ export class SharingCryptoService {
         return result;
     }
 
-    private async computeKeySaltAndPassphrase(password: string) {
-        if (!password) {
-            throw new Error('Password required.');
-        }
-
-        const salt = crypto.getRandomValues(new Uint8Array(16));
-        const hash: string = await bcrypt.hash(password, BCRYPT_PREFIX + bcrypt.encodeBase64(salt, 16));
-        // Remove bcrypt prefix and salt (first 29 characters)
-        const bcryptPassphrase = hash.slice(29);
-
-        return {
-            base64Salt: uint8ArrayToBase64String(salt),
-            bcryptPassphrase,
-        };
-    }
-
     async decryptPublicLink(encryptedPublicLink: EncryptedPublicLink): Promise<PublicLinkWithCreatorEmail> {
         const address = await this.account.getOwnAddress(encryptedPublicLink.creatorEmail);
         const addressKeys = address.keys.map(({ key }) => key);

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

@@ -1,10 +1,10 @@
 import { getMockLogger } from '../../tests/logger';
 import { DriveEvent, DriveEventType } from '../events';
+import { SharesManager } from '../shares/manager';
 import { SharingCache } from './cache';
-import { SharingAccess } from './sharingAccess';
 import { SharingEventHandler } from './events';
-import { SharesManager } from '../shares/manager';
 import { NodesService } from './interface';
+import { SharingAccess } from './sharingAccess';
 
 // FIXME: test tree_refresh and tree_remove
 

package/src/internal/sharing/index.ts

@@ -1,14 +1,14 @@
-import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveCrypto } from '../../crypto';
+import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveAPIService } from '../apiService';
 import { ShareTargetType } from '../shares';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
+import { SharingEventHandler } from './events';
+import { NodesService, SharesService } from './interface';
 import { SharingAccess } from './sharingAccess';
 import { SharingManagement } from './sharingManagement';
-import { SharesService, NodesService } from './interface';
-import { SharingEventHandler } from './events';
 
 // Root shares are not allowed to be shared.
 // Photos and Albums are not supported in main volume (core Drive).

package/src/internal/sharing/interface.ts

@@ -1,7 +1,7 @@
-import { NodeType, MemberRole, NonProtonInvitationState, MissingNode, ShareResult, PublicLink } from '../../interface';
 import { PrivateKey, SessionKey } from '../../crypto';
-import { EncryptedShare } from '../shares';
+import { MemberRole, MissingNode, NodeType, NonProtonInvitationState, PublicLink, ShareResult } from '../../interface';
 import { DecryptedNode } from '../nodes';
+import { EncryptedShare } from '../shares';
 
 export enum SharingType {
     SharedByMe = 'sharedByMe',

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

@@ -1,11 +1,11 @@
-import { getMockLogger } from '../../tests/logger';
-import { NodeType, resultError, resultOk, MemberRole } from '../../interface';
 import { ValidationError } from '../../errors';
+import { MemberRole, NodeType, resultError, resultOk } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
-import { SharesService, NodesService } from './interface';
-import { SharingAccess, BATCH_LOADING_SIZE } from './sharingAccess';
+import { NodesService, SharesService } from './interface';
+import { BATCH_LOADING_SIZE, SharingAccess } from './sharingAccess';
 
 describe('SharingAccess', () => {
     let apiService: SharingAPIService;

package/src/internal/sharing/sharingAccess.ts

@@ -1,13 +1,13 @@
 import { c } from 'ttag';
 
-import { MaybeBookmark, ProtonInvitationWithNode, resultError, resultOk } from '../../interface';
 import { ValidationError } from '../../errors';
-import { DecryptedNode } from '../nodes';
+import { MaybeBookmark, ProtonInvitationWithNode, resultError, resultOk } from '../../interface';
 import { BatchLoading } from '../batchLoading';
+import { DecryptedNode } from '../nodes';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
-import { SharesService, NodesService } from './interface';
+import { NodesService, SharesService } from './interface';
 
 // This is the number of nodes that are loaded in parallel.
 // It is a trade-off between initial wait time and overhead of API calls.