@protontech/drive-sdk 0.5.0 → 0.6.0

package/src/protonDrivePhotosClient.ts

@@ -10,12 +10,20 @@ import {
     MaybeNode,
     ThumbnailType,
     ThumbnailResult,
+    ShareNodeSettings,
+    ShareResult,
+    UnshareNodeSettings,
+    ProtonInvitationOrUid,
+    NonProtonInvitationOrUid,
+    ProtonInvitationWithNode,
+    NodeResult,
 } from './interface';
 import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
 import {
     convertInternalMissingNodeIterator,
+    convertInternalNode,
     convertInternalNodeIterator,
     convertInternalNodePromise,
     getUid,
@@ -25,7 +33,12 @@ import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import { initNodesModule } from './internal/nodes';
-import { initPhotosModule, initPhotoSharesModule, initPhotoUploadModule } from './internal/photos';
+import {
+    PHOTOS_SHARE_TARGET_TYPES,
+    initPhotosModule,
+    initPhotoSharesModule,
+    initPhotoUploadModule,
+} from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
@@ -72,7 +85,7 @@ export class ProtonDrivePhotosClient {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
-        this.logger = telemetry.getLogger('interface');
+        this.logger = telemetry.getLogger('photos-interface');
 
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
@@ -102,6 +115,7 @@ export class ProtonDrivePhotosClient {
             account,
             cryptoModule,
             this.photoShares,
+            fullConfig.clientUid,
         );
         this.photos = initPhotosModule(apiService, this.photoShares, this.nodes.access);
         this.sharing = initSharingModule(
@@ -112,6 +126,7 @@ export class ProtonDrivePhotosClient {
             cryptoModule,
             this.photoShares,
             this.nodes.access,
+            PHOTOS_SHARE_TARGET_TYPES,
         );
         this.download = initDownloadModule(
             telemetry,
@@ -204,6 +219,16 @@ export class ProtonDrivePhotosClient {
         yield* this.photos.timeline.iterateTimeline(signal);
     }
 
+    /**
+     * Iterates the trashed nodes.
+     *
+     * See `ProtonDriveClient.iterateTrashedNodes` for more information.
+     */
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating trashed nodes');
+        yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+    }
+
     /**
      * Iterates the nodes by their UIDs.
      *
@@ -226,14 +251,163 @@ export class ProtonDrivePhotosClient {
     }
 
     /**
-     * Iterates the albums.
+     * Rename the node.
      *
-     * The output is not sorted and the order of the nodes is not guaranteed.
+     * See `ProtonDriveClient.renameNode` for more information.
      */
-    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
-        this.logger.info('Iterating albums');
-        // TODO: expose album type
-        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+        this.logger.info(`Renaming node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
+    }
+
+    /**
+     * Trash the nodes.
+     *
+     * See `ProtonDriveClient.trashNodes` for more information.
+     */
+    async *trashNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Trashing ${nodeUids.length} nodes`);
+        yield* this.nodes.management.trashNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Restore the nodes from the trash to their original place.
+     *
+     * See `ProtonDriveClient.restoreNodes` for more information.
+     */
+    async *restoreNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Restoring ${nodeUids.length} nodes`);
+        yield* this.nodes.management.restoreNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Delete the nodes permanently.
+     *
+     * See `ProtonDriveClient.deleteNodes` for more information.
+     */
+    async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Deleting ${nodeUids.length} nodes`);
+        yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Empty the trash.
+     *
+     * See `ProtonDriveClient.emptyTrash` for more information.
+     */
+    async emptyTrash(): Promise<void> {
+        this.logger.info('Emptying trash');
+        throw new Error('Method not implemented');
+    }
+
+    /**
+     * Iterates the nodes shared by the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodes` for more information.
+     */
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes by me');
+        yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+    }
+
+    /**
+     * Iterates the nodes shared with the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodesWithMe` for more information.
+     */
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes with me');
+
+        for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
+            yield convertInternalNode(node);
+        }
+    }
+
+    /**
+     * Leave shared node that was previously shared with the user.
+     *
+     * See `ProtonDriveClient.leaveSharedNode` for more information.
+     */
+    async leaveSharedNode(nodeUid: NodeOrUid): Promise<void> {
+        this.logger.info(`Leaving shared node with me ${getUid(nodeUid)}`);
+        await this.sharing.access.removeSharedNodeWithMe(getUid(nodeUid));
+    }
+
+    /**
+     * Iterates the invitations to shared nodes.
+     *
+     * See `ProtonDriveClient.iterateInvitations` for more information.
+     */
+    async *iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+        this.logger.info('Iterating invitations');
+        yield* this.sharing.access.iterateInvitations(signal);
+    }
+
+    /**
+     * Accept the invitation to the shared node.
+     *
+     * See `ProtonDriveClient.acceptInvitation` for more information.
+     */
+    async acceptInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Accepting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.acceptInvitation(getUid(invitationUid));
+    }
+
+    /**
+     * Reject the invitation to the shared node.
+     *
+     * See `ProtonDriveClient.rejectInvitation` for more information.
+     */
+    async rejectInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Rejecting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.rejectInvitation(getUid(invitationUid));
+    }
+
+    /**
+     * Get sharing info of the node.
+     *
+     * See `ProtonDriveClient.getSharingInfo` for more information.
+     */
+    async getSharingInfo(nodeUid: NodeOrUid): Promise<ShareResult | undefined> {
+        this.logger.info(`Getting sharing info for ${getUid(nodeUid)}`);
+        return this.sharing.management.getSharingInfo(getUid(nodeUid));
+    }
+
+    /**
+     * Share or update sharing of the node.
+     *
+     * See `ProtonDriveClient.shareNode` for more information.
+     */
+    async shareNode(nodeUid: NodeOrUid, settings: ShareNodeSettings): Promise<ShareResult> {
+        this.logger.info(`Sharing node ${getUid(nodeUid)}`);
+        return this.sharing.management.shareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Unshare the node, completely or partially.
+     *
+     * See `ProtonDriveClient.unshareNode` for more information.
+     */
+    async unshareNode(nodeUid: NodeOrUid, settings?: UnshareNodeSettings): Promise<ShareResult | undefined> {
+        if (!settings) {
+            this.logger.info(`Unsharing node ${getUid(nodeUid)}`);
+        } else {
+            this.logger.info(`Partially unsharing ${getUid(nodeUid)}`);
+        }
+        return this.sharing.management.unshareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Resend the invitation email to shared node.
+     *
+     * See `ProtonDriveClient.resendInvitation` for more information.
+     */
+    async resendInvitation(
+        nodeUid: NodeOrUid,
+        invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
+    ): Promise<void> {
+        this.logger.info(`Resending invitation ${getUid(invitationUid)}`);
+        return this.sharing.management.resendInvitationEmail(getUid(nodeUid), getUid(invitationUid));
     }
 
     /**
@@ -279,4 +453,15 @@ export class ProtonDrivePhotosClient {
         const parentFolderUid = await this.nodes.access.getVolumeRootFolder();
         return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
     }
+
+    /**
+     * Iterates the albums.
+     *
+     * The output is not sorted and the order of the nodes is not guaranteed.
+     */
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating albums');
+        // TODO: expose album type
+        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    }
 }

package/src/protonDrivePublicLinkClient.ts

@@ -1,6 +1,6 @@
 import { MemoryCache } from './cache';
 import { getConfig } from './config';
-import { DriveCrypto, OpenPGPCrypto, SRPModule, SessionKey } from './crypto';
+import { DriveCrypto, OpenPGPCrypto, PrivateKey, SRPModule, SessionKey } from './crypto';
 import {
     ProtonDriveHTTPClient,
     ProtonDriveTelemetry,
@@ -74,7 +74,8 @@ export class ProtonDrivePublicLinkClient {
         telemetry,
         url,
         token,
-        password,
+        publicShareKey,
+        publicRootNodeUid,
     }: {
         httpClient: ProtonDriveHTTPClient;
         account: ProtonDriveAccount;
@@ -84,7 +85,8 @@ export class ProtonDrivePublicLinkClient {
         telemetry?: ProtonDriveTelemetry;
         url: string;
         token: string;
-        password: string;
+        publicShareKey: PrivateKey;
+        publicRootNodeUid: string;
     }) {
         if (!telemetry) {
             telemetry = new Telemetry();
@@ -115,7 +117,8 @@ export class ProtonDrivePublicLinkClient {
             account,
             url,
             token,
-            password,
+            publicShareKey,
+            publicRootNodeUid,
         );
         this.download = initDownloadModule(
             telemetry,

package/src/tests/telemetry.ts

@@ -1,9 +1,12 @@
-import { ProtonDriveTelemetry } from '../interface';
+import { Logger, ProtonDriveTelemetry } from '../interface';
 import { getMockLogger } from './logger';
 
-export function getMockTelemetry(): ProtonDriveTelemetry {
+export function getMockTelemetry(): ProtonDriveTelemetry & { mockLogger: Logger } {
+    const mockLogger = getMockLogger();
+
     return {
-        getLogger: getMockLogger,
+        mockLogger,
+        getLogger: () => mockLogger,
         recordMetric: jest.fn(),
     };
 }

package/src/transformers.ts

@@ -121,6 +121,14 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
     } as PublicNodeEntity);
 }
 
+export async function* convertInternalRevisionIterator(
+    revisionIterator: AsyncGenerator<InternalRevision>,
+): AsyncGenerator<PublicRevision> {
+    for await (const revision of revisionIterator) {
+        yield convertInternalRevision(revision);
+    }
+}
+
 function convertInternalRevision(revision: InternalRevision): PublicRevision {
     return {
         uid: revision.uid,

package/dist/diagnostic/sdkDiagnosticFull.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdkDiagnosticFull.js","sourceRoot":"","sources":["../../src/diagnostic/sdkDiagnosticFull.ts"],"names":[],"mappings":";;;AAIA,mDAAgD;AAEhD;;;GAGG;AACH,MAAa,iBAAiB;IAEd;IACA;IACA;IAHZ,YACY,UAAsB,EACtB,SAA8B,EAC9B,UAAgC;QAFhC,eAAU,GAAV,UAAU,CAAY;QACtB,cAAS,GAAT,SAAS,CAAqB;QAC9B,eAAU,GAAV,UAAU,CAAsB;QAExC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,CAAC,aAAa,CAAC,OAA2B;QAC5C,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,CAAC,cAAc,CAAC,IAAe,EAAE,OAA2B;QAC9D,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3E,CAAC;IAEO,KAAK,CAAC,CAAC,WAAW,CAAC,SAA2C;QAClE,KAAK,CAAC,CAAC,IAAA,6BAAa,EAAC,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACzF,CAAC;IAEO,KAAK,CAAC,CAAC,iBAAiB;QAC5B,KAAK,CAAC,CAAC,IAAA,6BAAa,EAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1F,CAAC;CACJ;AA1BD,8CA0BC"}

package/dist/internal/sharingPublic/cryptoCache.d.ts

@@ -1,15 +0,0 @@
-import { PrivateKey } from '../../crypto';
-import { ProtonDriveCryptoCache, Logger } from '../../interface';
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-export declare class SharingPublicCryptoCache {
-    private logger;
-    private driveCache;
-    constructor(logger: Logger, driveCache: ProtonDriveCryptoCache);
-    setShareKey(shareKey: PrivateKey): Promise<void>;
-    getShareKey(): Promise<PrivateKey>;
-}

package/dist/internal/sharingPublic/cryptoCache.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharingPublicCryptoCache = void 0;
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-class SharingPublicCryptoCache {
-    logger;
-    driveCache;
-    constructor(logger, driveCache) {
-        this.logger = logger;
-        this.driveCache = driveCache;
-        this.logger = logger;
-        this.driveCache = driveCache;
-    }
-    async setShareKey(shareKey) {
-        await this.driveCache.setEntity(getShareKeyCacheKey(), {
-            publicShareKey: {
-                key: shareKey,
-            },
-        });
-    }
-    async getShareKey() {
-        const shareKeyData = await this.driveCache.getEntity(getShareKeyCacheKey());
-        if (!shareKeyData.publicShareKey) {
-            try {
-                await this.driveCache.removeEntities([getShareKeyCacheKey()]);
-            }
-            catch (removingError) {
-                this.logger.warn(`Failed to remove corrupted public share key from the cache: ${removingError instanceof Error ? removingError.message : removingError}`);
-            }
-            throw new Error('Failed to deserialize public share key');
-        }
-        return shareKeyData.publicShareKey.key;
-    }
-}
-exports.SharingPublicCryptoCache = SharingPublicCryptoCache;
-function getShareKeyCacheKey() {
-    return 'publicShareKey';
-}
-//# sourceMappingURL=cryptoCache.js.map

package/dist/internal/sharingPublic/cryptoCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cryptoCache.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/cryptoCache.ts"],"names":[],"mappings":";;;AAGA;;;;;GAKG;AACH,MAAa,wBAAwB;IAErB;IACA;IAFZ,YACY,MAAc,EACd,UAAkC;QADlC,WAAM,GAAN,MAAM,CAAQ;QACd,eAAU,GAAV,UAAU,CAAwB;QAE1C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,QAAoB;QAClC,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE;YACnD,cAAc,EAAE;gBACZ,GAAG,EAAE,QAAQ;aAChB;SACJ,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,WAAW;QACb,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACD,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YAClE,CAAC;YAAC,OAAO,aAAsB,EAAE,CAAC;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,+DAA+D,aAAa,YAAY,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAC1I,CAAC;YACN,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,YAAY,CAAC,cAAc,CAAC,GAAG,CAAC;IAC3C,CAAC;CACJ;AA/BD,4DA+BC;AAED,SAAS,mBAAmB;IACxB,OAAO,gBAAgB,CAAC;AAC5B,CAAC"}

package/dist/internal/sharingPublic/cryptoService.d.ts

@@ -1,8 +0,0 @@
-import { DriveCrypto, PrivateKey } from '../../crypto';
-import { EncryptedShareCrypto } from './interface';
-export declare class SharingPublicCryptoService {
-    private driveCrypto;
-    private password;
-    constructor(driveCrypto: DriveCrypto, password: string);
-    decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey>;
-}

package/dist/internal/sharingPublic/cryptoService.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharingPublicCryptoService = void 0;
-class SharingPublicCryptoService {
-    driveCrypto;
-    password;
-    constructor(driveCrypto, password) {
-        this.driveCrypto = driveCrypto;
-        this.password = password;
-        this.driveCrypto = driveCrypto;
-        this.password = password;
-    }
-    async decryptPublicLinkShareKey(encryptedShare) {
-        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(this.password, encryptedShare.base64UrlPasswordSalt, encryptedShare.armoredKey, encryptedShare.armoredPassphrase);
-        return shareKey;
-    }
-}
-exports.SharingPublicCryptoService = SharingPublicCryptoService;
-//# sourceMappingURL=cryptoService.js.map

package/dist/internal/sharingPublic/cryptoService.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cryptoService.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/cryptoService.ts"],"names":[],"mappings":";;;AAGA,MAAa,0BAA0B;IAEvB;IACA;IAFZ,YACY,WAAwB,EACxB,QAAgB;QADhB,gBAAW,GAAX,WAAW,CAAa;QACxB,aAAQ,GAAR,QAAQ,CAAQ;QAExB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,yBAAyB,CAAC,cAAoC;QAChE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,yBAAyB,CACtE,IAAI,CAAC,QAAQ,EACb,cAAc,CAAC,qBAAqB,EACpC,cAAc,CAAC,UAAU,EACzB,cAAc,CAAC,iBAAiB,CACnC,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ;AAlBD,gEAkBC"}

package/dist/internal/sharingPublic/interface.d.ts

@@ -1,5 +0,0 @@
-export interface EncryptedShareCrypto {
-    base64UrlPasswordSalt: string;
-    armoredKey: string;
-    armoredPassphrase: string;
-}

package/dist/internal/sharingPublic/interface.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interface.js.map

package/dist/internal/sharingPublic/interface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/interface.ts"],"names":[],"mappings":""}

package/src/internal/sharingPublic/cryptoCache.ts

@@ -1,45 +0,0 @@
-import { PrivateKey } from '../../crypto';
-import { ProtonDriveCryptoCache, Logger } from '../../interface';
-
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-export class SharingPublicCryptoCache {
-    constructor(
-        private logger: Logger,
-        private driveCache: ProtonDriveCryptoCache,
-    ) {
-        this.logger = logger;
-        this.driveCache = driveCache;
-    }
-
-    async setShareKey(shareKey: PrivateKey): Promise<void> {
-        await this.driveCache.setEntity(getShareKeyCacheKey(), {
-            publicShareKey: {
-                key: shareKey,
-            },
-        });
-    }
-
-    async getShareKey(): Promise<PrivateKey> {
-        const shareKeyData = await this.driveCache.getEntity(getShareKeyCacheKey());
-        if (!shareKeyData.publicShareKey) {
-            try {
-                await this.driveCache.removeEntities([getShareKeyCacheKey()]);
-            } catch (removingError: unknown) {
-                this.logger.warn(
-                    `Failed to remove corrupted public share key from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
-                );
-            }
-            throw new Error('Failed to deserialize public share key');
-        }
-        return shareKeyData.publicShareKey.key;
-    }
-}
-
-function getShareKeyCacheKey() {
-    return 'publicShareKey';
-}

package/src/internal/sharingPublic/cryptoService.ts

@@ -1,22 +0,0 @@
-import { DriveCrypto, PrivateKey } from '../../crypto';
-import { EncryptedShareCrypto } from './interface';
-
-export class SharingPublicCryptoService {
-    constructor(
-        private driveCrypto: DriveCrypto,
-        private password: string,
-    ) {
-        this.driveCrypto = driveCrypto;
-        this.password = password;
-    }
-
-    async decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey> {
-        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
-            this.password,
-            encryptedShare.base64UrlPasswordSalt,
-            encryptedShare.armoredKey,
-            encryptedShare.armoredPassphrase,
-        );
-        return shareKey;
-    }
-}

package/src/internal/sharingPublic/interface.ts

@@ -1,5 +0,0 @@
-export interface EncryptedShareCrypto {
-    base64UrlPasswordSalt: string;
-    armoredKey: string;
-    armoredPassphrase: string;
-}