@protontech/drive-sdk 0.3.1 → 0.4.0

package/src/internal/apiService/errorCodes.ts

@@ -18,6 +18,7 @@ export const enum ErrorCode {
     OK = 1000,
     OK_MANY = 1001,
     OK_ASYNC = 1002,
+    INVALID_REQUIREMENTS = 2000,
     INVALID_VALUE = 2001,
     NOT_ENOUGH_PERMISSIONS = 2011,
     NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS = 2026,

package/src/internal/apiService/errors.ts

@@ -57,6 +57,8 @@ export function apiErrorFactory({
         // Here we convert only general enough codes. Specific cases that are
         // not clear from the code itself must be handled by each module
         // separately.
+        case ErrorCode.INVALID_REQUIREMENTS:
+            return new InvalidRequirementsAPIError(message, code, details);
         case ErrorCode.INVALID_VALUE:
         case ErrorCode.NOT_ENOUGH_PERMISSIONS:
         case ErrorCode.NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS:
@@ -108,3 +110,7 @@ export class APICodeError extends ServerError {
 export class NotFoundAPIError extends ValidationError {
     name = 'NotFoundAPIError';
 }
+
+export class InvalidRequirementsAPIError extends ValidationError {
+    name = 'InvalidRequirementsAPIError';
+}

package/src/internal/devices/interface.ts

@@ -13,7 +13,7 @@ export type DeviceMetadata = {
 };
 
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string }>;
+    getOwnVolumeIDs(): 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 = {
-            getMyFilesIDs: jest.fn(),
+            getOwnVolumeIDs: 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.getMyFilesIDs.mockResolvedValue({ volumeId });
+        sharesService.getOwnVolumeIDs.mockResolvedValue({ volumeId });
         cryptoService.createDevice.mockResolvedValue({ address, shareKey, node });
         apiService.createDevice.mockResolvedValue(createdDevice);
 
         const result = await manager.createDevice(name, deviceType);
 
-        expect(sharesService.getMyFilesIDs).toHaveBeenCalled();
+        expect(sharesService.getOwnVolumeIDs).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.getMyFilesIDs();
+        const { volumeId } = await this.sharesService.getOwnVolumeIDs();
         const { address, shareKey, node } = await this.cryptoService.createDevice(name);
 
         const device = await this.apiService.createDevice(

package/src/internal/download/cryptoService.ts

@@ -49,7 +49,7 @@ export class DownloadCryptoService {
             );
         } catch (error: unknown) {
             const message = getErrorMessage(error);
-            throw new DecryptionError(c('Error').t`Failed to decrypt block: ${message}`);
+            throw new DecryptionError(c('Error').t`Failed to decrypt block: ${message}`, { cause: error });
         }
 
         return decryptedBlock;
@@ -66,7 +66,7 @@ export class DownloadCryptoService {
             decryptedBlock = result.decryptedThumbnail;
         } catch (error: unknown) {
             const message = getErrorMessage(error);
-            throw new DecryptionError(c('Error').t`Failed to decrypt thumbnail: ${message}`);
+            throw new DecryptionError(c('Error').t`Failed to decrypt thumbnail: ${message}`, { cause: error });
         }
 
         return decryptedBlock;

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

@@ -123,8 +123,10 @@ describe('FileDownloader', () => {
 
         const verifyOnProgress = async (downloadedBytes: number[]) => {
             expect(onProgress).toHaveBeenCalledTimes(downloadedBytes.length);
+            let fileProgress = 0;
             for (let i = 0; i < downloadedBytes.length; i++) {
-                expect(onProgress).toHaveBeenNthCalledWith(i + 1, downloadedBytes[i]);
+                fileProgress += downloadedBytes[i];
+                expect(onProgress).toHaveBeenNthCalledWith(i + 1, fileProgress);
             }
         };
 

package/src/internal/download/fileDownloader.ts

@@ -134,7 +134,7 @@ export class FileDownloader {
             const blockData = await this.downloadBlockData(blockMetadata, true, cryptoKeys);
             return blockData.slice(blockOffset);
         } catch (error: unknown) {
-            return error instanceof Error ? error : new Error(`Unknown error: ${error}`);
+            return error instanceof Error ? error : new Error(`Unknown error: ${error}`, { cause: error });
         }
     }
 
@@ -193,7 +193,7 @@ export class FileDownloader {
                     cryptoKeys,
                     (downloadedBytes) => {
                         fileProgress += downloadedBytes;
-                        onProgress?.(downloadedBytes);
+                        onProgress?.(fileProgress);
                     },
                 );
                 this.ongoingDownloads.set(blockMetadata.index, { downloadPromise });

package/src/internal/events/apiService.ts

@@ -57,7 +57,7 @@ export class EventsAPIService {
         return {
             latestEventId: result.EventID,
             more: result.More === 1,
-            refresh: result.Refresh === 1,
+            refresh,
             events,
         };
     }

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

@@ -46,29 +46,6 @@ describe('CoreEventManager', () => {
         const eventId = 'event1';
         const latestEventId = 'event2';
 
-        it('should yield ShareWithMeUpdated event when refresh is true', async () => {
-            const mockEvents: DriveEventsListWithStatus = {
-                latestEventId,
-                more: false,
-                refresh: true,
-                events: [],
-            };
-            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
-
-            const events = [];
-            for await (const event of coreEventManager.getEvents(eventId)) {
-                events.push(event);
-            }
-
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual({
-                type: DriveEventType.SharedWithMeUpdated,
-                treeEventScopeId: 'core',
-                eventId: latestEventId,
-            });
-            expect(mockApiService.getCoreEvents).toHaveBeenCalledWith(eventId);
-        });
-
         it('should yield all events when there are actual events', async () => {
             const mockEvent1: DriveEvent = {
                 type: DriveEventType.SharedWithMeUpdated,
@@ -88,14 +65,31 @@ describe('CoreEventManager', () => {
             };
             mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
 
-            const events = [];
-            for await (const event of coreEventManager.getEvents(eventId)) {
-                events.push(event);
-            }
+            const events = await Array.fromAsync(coreEventManager.getEvents(eventId));
 
             expect(events).toHaveLength(2);
             expect(events[0]).toEqual(mockEvent1);
             expect(events[1]).toEqual(mockEvent2);
         });
+
+        it('should yield FastForward event there are no events but lastEventId changed', async () => {
+            const mockEvents: DriveEventsListWithStatus = {
+                latestEventId,
+                more: false,
+                refresh: false,
+                events: [],
+            };
+            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
+
+            const events = await Array.fromAsync(coreEventManager.getEvents(eventId));
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'core',
+                eventId: latestEventId,
+            });
+            expect(mockApiService.getCoreEvents).toHaveBeenCalledWith(eventId);
+        });
     });
 });

package/src/internal/events/coreEventManager.ts

@@ -32,7 +32,7 @@ export class CoreEventManager implements EventManagerInterface<DriveEvent> {
         const events = await this.apiService.getCoreEvents(eventId);
         if (events.events.length === 0 && events.latestEventId !== eventId) {
             yield {
-                type: DriveEventType.SharedWithMeUpdated,
+                type: DriveEventType.FastForward,
                 treeEventScopeId: 'core',
                 eventId: events.latestEventId,
             };

package/src/internal/events/index.ts

@@ -1,11 +1,10 @@
 import { Logger, ProtonDriveTelemetry } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider } from './interface';
+import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider, SharesService } from './interface';
 import { EventsAPIService } from './apiService';
 import { CoreEventManager } from './coreEventManager';
 import { VolumeEventManager } from './volumeEventManager';
 import { EventManager } from './eventManager';
-import { SharesManager } from '../shares/manager';
 
 export type { DriveEvent, DriveListener, EventSubscription } from './interface';
 export { DriveEventType } from './interface';
@@ -28,7 +27,7 @@ export class DriveEventsService {
     constructor(
         private telemetry: ProtonDriveTelemetry,
         apiService: DriveAPIService,
-        private shareManagement: SharesManager,
+        private sharesService: SharesService,
         private cacheEventListeners: DriveListener[] = [],
         private latestEventIdProvider?: LatestEventIdProvider,
     ) {
@@ -104,7 +103,7 @@ export class DriveEventsService {
         this.logger.debug(`Creating volume event manager for volume ${volumeId}`);
         const volumeEventManager = new VolumeEventManager(this.logger, this.apiService, volumeId);
 
-        const isOwnVolume = await this.shareManagement.isOwnVolume(volumeId);
+        const isOwnVolume = await this.sharesService.isOwnVolume(volumeId);
         const pollingInterval = this.getDefaultVolumePollingInterval(isOwnVolume);
         const latestEventId = this.latestEventIdProvider.getLatestEventId(volumeId);
         const eventManager = new EventManager<DriveEvent>(volumeEventManager, pollingInterval, latestEventId);

package/src/internal/events/interface.ts

@@ -112,3 +112,7 @@ export interface EventManagerInterface<T> {
     getEvents(eventId: string): AsyncIterable<T>;
     getLogger(): Logger;
 }
+
+export interface SharesService {
+    isOwnVolume(volumeId: string): Promise<boolean>;
+}

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

@@ -1,7 +1,8 @@
 import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
-import { DriveAPIService, ErrorCode } from '../apiService';
+import { DriveAPIService, ErrorCode, InvalidRequirementsAPIError } from '../apiService';
 import { NodeAPIService } from './apiService';
+import { NodeOutOfSyncError } from './errors';
 
 function generateAPIFileNode(linkOverrides = {}, overrides = {}) {
     const node = generateAPINode();
@@ -542,4 +543,37 @@ describe('nodeAPIService', () => {
             }
         });
     });
+
+    describe('renameNode', () => {
+        it('should rename node', async () => {
+            await api.renameNode(
+                'volumeId~nodeId1',
+                { hash: 'originalHash' },
+                { encryptedName: 'encryptedName1', nameSignatureEmail: 'nameSignatureEmail1', hash: 'newHash' },
+            );
+
+            expect(apiMock.put).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId/links/nodeId1/rename',
+                {
+                    Name: 'encryptedName1',
+                    NameSignatureEmail: 'nameSignatureEmail1',
+                    Hash: 'newHash',
+                    OriginalHash: 'originalHash',
+                },
+                undefined,
+            );
+        });
+
+        it('should throw error if node is out of sync', async () => {
+            apiMock.put = jest.fn().mockRejectedValue(new InvalidRequirementsAPIError('Node is out of sync'));
+
+            await expect(
+                api.renameNode(
+                    'volumeId~nodeId1',
+                    { hash: 'originalHash' },
+                    { encryptedName: 'encryptedName1', nameSignatureEmail: 'nameSignatureEmail1', hash: 'newHash' },
+                ),
+            ).rejects.toThrow(new NodeOutOfSyncError('Node is out of sync'));
+        });
+    });
 });

package/src/internal/nodes/apiService.ts

@@ -6,6 +6,7 @@ import { MemberRole, RevisionState } from '../../interface/nodes';
 import {
     DriveAPIService,
     drivePaths,
+    InvalidRequirementsAPIError,
     isCodeOk,
     nodeTypeNumberToNodeType,
     permissionsToMemberRole,
@@ -13,7 +14,8 @@ import {
 import { asyncIteratorRace } from '../asyncIteratorRace';
 import { batch } from '../batch';
 import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from '../uids';
-import { EncryptedNode, EncryptedRevision, Thumbnail } from './interface';
+import { NodeOutOfSyncError } from './errors';
+import { EncryptedNode, EncryptedRevision, FilterOptions, Thumbnail } from './interface';
 
 // This is the number of calls to the API that are made in parallel.
 const API_CONCURRENCY = 15;
@@ -48,6 +50,13 @@ type PutMoveNodeRequest = Extract<
 type PutMoveNodeResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['responses']['200']['content']['application/json'];
 
+type PostCopyNodeRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCopyNodeResponse =
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['responses']['200']['content']['application/json'];
+
 type PostTrashNodesRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'],
     { content: object }
@@ -108,7 +117,7 @@ export class NodeAPIService {
     }
 
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
-        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
+        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, undefined, signal);
         const result = await nodesGenerator.next();
         if (!result.value) {
             throw new ValidationError(c('Error').t`Node not found`);
@@ -117,7 +126,12 @@ export class NodeAPIService {
         return result.value;
     }
 
-    async *iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
+    async *iterateNodes(
+        nodeUids: string[],
+        ownVolumeId: string,
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<EncryptedNode> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -139,7 +153,13 @@ export class NodeAPIService {
                 const isAdmin = volumeId === ownVolumeId;
 
                 yield (async function* () {
-                    const errorsPerVolume = yield* iterateNodesPerVolume(volumeId, nodeIds, isAdmin, signal);
+                    const errorsPerVolume = yield* iterateNodesPerVolume(
+                        volumeId,
+                        nodeIds,
+                        isAdmin,
+                        filterOptions,
+                        signal,
+                    );
                     if (errorsPerVolume.length) {
                         errors.push(...errorsPerVolume);
                     }
@@ -159,6 +179,7 @@ export class NodeAPIService {
         volumeId: string,
         nodeIds: string[],
         isOwnVolumeId: boolean,
+        filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<EncryptedNode, unknown[]> {
         const errors: unknown[] = [];
@@ -174,7 +195,11 @@ export class NodeAPIService {
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    const encryptedNode = linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    if (filterOptions?.type && encryptedNode.type !== filterOptions.type) {
+                        continue;
+                    }
+                    yield encryptedNode;
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -186,13 +211,25 @@ export class NodeAPIService {
     }
 
     // Improvement requested: load next page sooner before all IDs are yielded.
-    async *iterateChildrenNodeUids(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<string> {
+    async *iterateChildrenNodeUids(
+        parentNodeUid: string,
+        onlyFolders: boolean = false,
+        signal?: AbortSignal,
+    ): AsyncGenerator<string> {
         const { volumeId, nodeId } = splitNodeUid(parentNodeUid);
 
         let anchor = '';
         while (true) {
+            const queryParams = new URLSearchParams();
+            if (onlyFolders) {
+                queryParams.set('FoldersOnly', '1');
+            }
+            if (anchor) {
+                queryParams.set('AnchorID', anchor);
+            }
+
             const response = await this.apiService.get<GetChildrenResponse>(
-                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${queryParams.toString()}`,
                 signal,
             );
             for (const linkID of response.LinkIDs) {
@@ -251,16 +288,28 @@ export class NodeAPIService {
     ): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
 
-        await this.apiService.put<Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>, PutRenameNodeResponse>(
-            `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
-            {
-                Name: newNode.encryptedName,
-                NameSignatureEmail: newNode.nameSignatureEmail,
-                Hash: newNode.hash,
-                OriginalHash: originalNode.hash || null,
-            },
-            signal,
-        );
+        try {
+            await this.apiService.put<
+                Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>,
+                PutRenameNodeResponse
+            >(
+                `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
+                {
+                    Name: newNode.encryptedName,
+                    NameSignatureEmail: newNode.nameSignatureEmail,
+                    Hash: newNode.hash,
+                    OriginalHash: originalNode.hash || null,
+                },
+                signal,
+            );
+        } catch (error: unknown) {
+            // API returns generic code 2000 when node is out of sync.
+            // We map this to specific error for clarity.
+            if (error instanceof InvalidRequirementsAPIError) {
+                throw new NodeOutOfSyncError(error.message, error.code, { cause: error });
+            }
+            throw error;
+        }
     }
 
     async moveNode(
@@ -303,6 +352,43 @@ export class NodeAPIService {
         );
     }
 
+    async copyNode(
+        nodeUid: string,
+        newNode: {
+            parentUid: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature?: string;
+            signatureEmail?: string;
+            encryptedName: string;
+            nameSignatureEmail?: string;
+            hash: string;
+        },
+        signal?: AbortSignal,
+    ): Promise<string> {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        const { volumeId: parentVolumeId, nodeId: parentNodeId } = splitNodeUid(newNode.parentUid);
+
+        const response = await this.apiService.post<PostCopyNodeRequest, PostCopyNodeResponse>(
+            `drive/volumes/${volumeId}/links/${nodeId}/copy`,
+            {
+                TargetVolumeID: parentVolumeId,
+                TargetParentLinkID: parentNodeId,
+                NodePassphrase: newNode.armoredNodePassphrase,
+                // @ts-expect-error: API accepts NodePassphraseSignature as optional.
+                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                // @ts-expect-error: API accepts SignatureEmail as optional.
+                SignatureEmail: newNode.signatureEmail,
+                Name: newNode.encryptedName,
+                // @ts-expect-error: API accepts NameSignatureEmail as optional.
+                NameSignatureEmail: newNode.nameSignatureEmail,
+                Hash: newNode.hash,
+            },
+            signal,
+        );
+
+        return makeNodeUid(volumeId, response.LinkID);
+    }
+
     // Improvement requested: split into multiple calls for many nodes.
     async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const nodeIds = nodeUids.map(splitNodeUid);

package/src/internal/nodes/cache.ts

@@ -53,7 +53,9 @@ export class NodesCache {
             return deserialiseNode(nodeData);
         } catch (error: unknown) {
             await this.removeCorruptedNode({ nodeUid }, error);
-            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`);
+            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`, {
+                cause: error,
+            });
         }
     }
 

package/src/internal/nodes/cryptoReporter.ts

@@ -0,0 +1,145 @@
+import { VERIFICATION_STATUS } from '../../crypto';
+import {
+    resultOk,
+    resultError,
+    Author,
+    AnonymousUser,
+    ProtonDriveTelemetry,
+    Logger,
+    MetricsDecryptionErrorField,
+    MetricVerificationErrorField,
+} from '../../interface';
+import { getVerificationMessage } from '../errors';
+import { splitNodeUid } from '../uids';
+import {
+    EncryptedNode,
+    SharesService,
+} from './interface';
+
+export class NodesCryptoReporter {
+    private logger: Logger;
+
+    private reportedDecryptionErrors = new Set<string>();
+    private reportedVerificationErrors = new Set<string>();
+
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private shareService: SharesService,
+    ) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('nodes-crypto');
+        this.shareService = shareService;
+    }
+
+    async handleClaimedAuthor(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys = false,
+    ): Promise<Author> {
+        const author = handleClaimedAuthor(
+            signatureType,
+            verified,
+            verificationErrors,
+            claimedAuthor,
+            notAvailableVerificationKeys,
+        );
+        if (!author.ok) {
+            void this.reportVerificationError(node, field, verificationErrors, claimedAuthor);
+        }
+        return author;
+    }
+
+    async reportVerificationError(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+    ) {
+        if (this.reportedVerificationErrors.has(node.uid)) {
+            return;
+        }
+        this.reportedVerificationErrors.add(node.uid);
+
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        let addressMatchingDefaultShare, volumeType;
+        try {
+            const { volumeId } = splitNodeUid(node.uid);
+            const { email } = await this.shareService.getMyFilesShareMemberEmailKey();
+            addressMatchingDefaultShare = claimedAuthor ? claimedAuthor === email : undefined;
+            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
+        } catch (error: unknown) {
+            this.logger.error('Failed to check if claimed author matches default share', error);
+        }
+
+        this.logger.warn(
+            `Failed to verify ${field} for node ${node.uid} (from before 2024: ${fromBefore2024}, matching address: ${addressMatchingDefaultShare})`,
+        );
+
+        this.telemetry.recordMetric({
+            eventName: 'verificationError',
+            volumeType,
+            field,
+            addressMatchingDefaultShare,
+            fromBefore2024,
+            error: verificationErrors?.map((e) => e.message).join(', '),
+            uid: node.uid,
+        });
+    }
+
+    async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
+        if (this.reportedDecryptionErrors.has(node.uid)) {
+            return;
+        }
+
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        let volumeType;
+        try {
+            const { volumeId } = splitNodeUid(node.uid);
+            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
+        } catch (error: unknown) {
+            this.logger.error('Failed to get metric context', error);
+        }
+
+        this.logger.error(`Failed to decrypt node ${node.uid} (from before 2024: ${fromBefore2024})`, error);
+
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
+        this.reportedDecryptionErrors.add(node.uid);
+    }
+}
+
+/**
+ * @param signatureType - Must be translated before calling this function.
+ */
+function handleClaimedAuthor(
+    signatureType: string,
+    verified: VERIFICATION_STATUS,
+    verificationErrors?: Error[],
+    claimedAuthor?: string,
+    notAvailableVerificationKeys = false,
+): Author {
+    if (!claimedAuthor && notAvailableVerificationKeys) {
+        return resultOk(null as AnonymousUser);
+    }
+
+    if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
+        return resultOk(claimedAuthor || (null as AnonymousUser));
+    }
+
+    return resultError({
+        claimedAuthor,
+        error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+    });
+}