@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/internal/shares/apiService.ts

@@ -1,20 +1,29 @@
-import { DriveAPIService, drivePaths } from "../apiService";
-import { makeMemberUid } from "../uids";
-import { EncryptedShare, EncryptedRootShare, EncryptedShareCrypto, ShareType } from "./interface";
-
-type PostCreateVolumeRequest = Extract<drivePaths['/drive/volumes']['post']['requestBody'], { 'content': object }>['content']['application/json'];
+import { DriveAPIService, drivePaths } from '../apiService';
+import { makeMemberUid } from '../uids';
+import { EncryptedShare, EncryptedRootShare, EncryptedShareCrypto, ShareType } from './interface';
+
+type PostCreateVolumeRequest = Extract<
+    drivePaths['/drive/volumes']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
 type PostCreateVolumeResponse = drivePaths['/drive/volumes']['post']['responses']['200']['content']['application/json'];
 
-type PostCreateShareRequest = Extract<drivePaths['/drive/volumes/{volumeID}/shares']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCreateShareResponse = drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
-
-type GetMyFilesResponse = drivePaths['/drive/v2/shares/my-files']['get']['responses']['200']['content']['application/json'];
-type GetVolumeResponse = drivePaths['/drive/volumes/{volumeID}']['get']['responses']['200']['content']['application/json'];
+type PostCreateShareRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/shares']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateShareResponse =
+    drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
+
+type GetMyFilesResponse =
+    drivePaths['/drive/v2/shares/my-files']['get']['responses']['200']['content']['application/json'];
+type GetVolumeResponse =
+    drivePaths['/drive/volumes/{volumeID}']['get']['responses']['200']['content']['application/json'];
 type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for fetching shares and creating volumes.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
@@ -44,7 +53,7 @@ export class SharesAPIService {
         const response = await this.apiService.get<GetVolumeResponse>(`drive/volumes/${volumeId}`);
         return {
             shareId: response.Volume.Share.ShareID,
-        }
+        };
     }
 
     async getShare(shareId: string): Promise<EncryptedShare> {
@@ -54,11 +63,11 @@ export class SharesAPIService {
 
     /**
      * Returns root share with address key.
-     * 
+     *
      * This function provides access to root shares that provides access
      * to node tree via address key. For this reason, caller must use this
      * only when it is clear the shareId is root share.
-     * 
+     *
      * @throws Error when share is not root share.
      */
     async getRootShare(shareId: string): Promise<EncryptedRootShare> {
@@ -76,17 +85,17 @@ export class SharesAPIService {
 
     async createVolume(
         share: {
-            addressId: string,
-            addressKeyId: string,
+            addressId: string;
+            addressKeyId: string;
         } & EncryptedShareCrypto,
         node: {
-            encryptedName: string,
-            armoredKey: string,
-            armoredPassphrase: string,
-            armoredPassphraseSignature: string,
-            armoredHashKey: string,
+            encryptedName: string;
+            armoredKey: string;
+            armoredPassphrase: string;
+            armoredPassphraseSignature: string;
+            armoredHashKey: string;
         },
-    ): Promise<{ volumeId: string, shareId: string, rootNodeId: string }> {
+    ): Promise<{ volumeId: string; shareId: string; rootNodeId: string }> {
         const response = await this.apiService.post<
             // Volume & share names are deprecated.
             Omit<PostCreateVolumeRequest, 'VolumeName' | 'ShareName'>,
@@ -108,19 +117,19 @@ export class SharesAPIService {
             volumeId: response.Volume.ID,
             shareId: response.Volume.Share.ShareID,
             rootNodeId: response.Volume.Share.LinkID,
-        }
+        };
     }
 
     async createShare(
         volumeId: string,
         share: {
-            addressId: string,
+            addressId: string;
         } & EncryptedShareCrypto,
         node: {
-            nodeId: string,
-            encryptedName: string,
-            nameKeyPacket: string,
-            passphraseKeyPacket: string,
+            nodeId: string;
+            encryptedName: string;
+            nameKeyPacket: string;
+            passphraseKeyPacket: string;
         },
     ): Promise<{ shareId: string }> {
         const response = await this.apiService.post<
@@ -139,7 +148,7 @@ export class SharesAPIService {
 
         return {
             shareId: response.Share.ID,
-        }
+        };
     }
 }
 
@@ -149,15 +158,17 @@ function convertSharePayload(response: GetShareResponse): EncryptedShare {
         shareId: response.ShareID,
         rootNodeId: response.LinkID,
         creatorEmail: response.Creator,
-        creationTime: response.CreateTime ? new Date(response.CreateTime*1000) : undefined,
+        creationTime: response.CreateTime ? new Date(response.CreateTime * 1000) : undefined,
         encryptedCrypto: {
             armoredKey: response.Key,
             armoredPassphrase: response.Passphrase,
             armoredPassphraseSignature: response.PassphraseSignature,
         },
-        membership: response.Memberships?.[0] ? {
-            memberUid: makeMemberUid(response.ShareID, response.Memberships[0].MemberID),
-        } : undefined,
+        membership: response.Memberships?.[0]
+            ? {
+                  memberUid: makeMemberUid(response.ShareID, response.Memberships[0].MemberID),
+              }
+            : undefined,
         type: convertShareTypeNumberToEnum(response.Type),
     };
 }

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

@@ -1,6 +1,6 @@
-import { MemoryCache } from "../../cache";
-import { getMockLogger } from "../../tests/logger";
-import { SharesCache } from "./cache";
+import { MemoryCache } from '../../cache';
+import { getMockLogger } from '../../tests/logger';
+import { SharesCache } from './cache';
 
 describe('sharesCache', () => {
     let memoryCache: MemoryCache<string>;
@@ -45,7 +45,9 @@ describe('sharesCache', () => {
             await cache.getVolume('badObject');
             fail('Should have thrown an error');
         } catch (error) {
-            expect(`${error}`).toBe('Error: Failed to deserialize volume: Unexpected token \'a\', \"aaa\" is not valid JSON');
+            expect(`${error}`).toBe(
+                'Error: Failed to deserialize volume: Unexpected token \'a\', \"aaa\" is not valid JSON',
+            );
         }
 
         try {

package/src/internal/shares/cache.ts

@@ -1,6 +1,6 @@
-import { ProtonDriveEntitiesCache, Logger } from "../../interface";
-import { getErrorMessage } from "../errors";
-import { Volume } from "./interface";
+import { ProtonDriveEntitiesCache, Logger } from '../../interface';
+import { getErrorMessage } from '../errors';
+import { Volume } from './interface';
 
 /**
  * Provides caching for shares and volume metadata.
@@ -10,7 +10,10 @@ import { Volume } from "./interface";
  * This is only intended for the owner's main volume. There is no cache invalidation.
  */
 export class SharesCache {
-    constructor(private logger: Logger, private driveCache: ProtonDriveEntitiesCache) {
+    constructor(
+        private logger: Logger,
+        private driveCache: ProtonDriveEntitiesCache,
+    ) {
         this.logger = logger;
         this.driveCache = driveCache;
     }
@@ -51,14 +54,20 @@ function serializeVolume(volume: Volume) {
 }
 
 function deserializeVolume(shareData: string): Volume {
-     const volume = JSON.parse(shareData);
-     if (
-        !volume || typeof volume !== 'object' ||
-        !volume.volumeId || typeof volume.volumeId !== 'string' ||
-        !volume.shareId || typeof volume.shareId !== 'string' ||
-        !volume.rootNodeId || typeof volume.rootNodeId !== 'string' ||
-        !volume.creatorEmail || typeof volume.creatorEmail !== 'string' ||
-        !volume.addressId || typeof volume.addressId !== 'string'
+    const volume = JSON.parse(shareData);
+    if (
+        !volume ||
+        typeof volume !== 'object' ||
+        !volume.volumeId ||
+        typeof volume.volumeId !== 'string' ||
+        !volume.shareId ||
+        typeof volume.shareId !== 'string' ||
+        !volume.rootNodeId ||
+        typeof volume.rootNodeId !== 'string' ||
+        !volume.creatorEmail ||
+        typeof volume.creatorEmail !== 'string' ||
+        !volume.addressId ||
+        typeof volume.addressId !== 'string'
     ) {
         throw new Error('Invalid volume data');
     }

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

@@ -1,19 +1,19 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { MemoryCache } from "../../cache";
-import { CachedCryptoMaterial } from "../../interface";
-import { SharesCryptoCache } from "./cryptoCache";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { MemoryCache } from '../../cache';
+import { CachedCryptoMaterial } from '../../interface';
+import { SharesCryptoCache } from './cryptoCache';
 
 describe('sharesCryptoCache', () => {
     let memoryCache: MemoryCache<CachedCryptoMaterial>;
     let cache: SharesCryptoCache;
 
     const generatePrivateKey = (name: string) => {
-        return name as unknown as PrivateKey
-    }
+        return name as unknown as PrivateKey;
+    };
 
     const generateSessionKey = (name: string) => {
-        return name as unknown as SessionKey
-    }
+        return name as unknown as SessionKey;
+    };
 
     beforeEach(() => {
         memoryCache = new MemoryCache();
@@ -32,8 +32,14 @@ describe('sharesCryptoCache', () => {
 
     it('should replace and retrieve new keys', async () => {
         const shareId = 'newShareId';
-        const keys1 = { key: generatePrivateKey('privateKey1'), passphraseSessionKey: generateSessionKey('sessionKey1') };
-        const keys2 = { key: generatePrivateKey('privateKey2'), passphraseSessionKey: generateSessionKey('sessionKey2') };
+        const keys1 = {
+            key: generatePrivateKey('privateKey1'),
+            passphraseSessionKey: generateSessionKey('sessionKey1'),
+        };
+        const keys2 = {
+            key: generatePrivateKey('privateKey2'),
+            passphraseSessionKey: generateSessionKey('sessionKey2'),
+        };
 
         await cache.setShareKey(shareId, keys1);
         await cache.setShareKey(shareId, keys2);
@@ -67,4 +73,4 @@ describe('sharesCryptoCache', () => {
             expect(`${error}`).toBe('Error: Entity not found');
         }
     });
-});
+});

package/src/internal/shares/cryptoCache.ts

@@ -1,12 +1,12 @@
-import { ProtonDriveCryptoCache } from "../../interface";
-import { DecryptedShareKey } from "./interface";
+import { ProtonDriveCryptoCache } from '../../interface';
+import { DecryptedShareKey } from './interface';
 
 /**
  * Provides caching for share crypto material.
- * 
+ *
  * The cache is responsible for serialising and deserialising share
  * crypto material.
- * 
+ *
  * The share crypto materials are cached so the updates to the root
  * nodes can be decrypted without the need to fetch the share keys
  * from the server again. Otherwise the rest of the tree requires

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

@@ -1,10 +1,10 @@
-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 { 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';
 
-describe("SharesCryptoService", () => {
+describe('SharesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;
     let driveCrypto: DriveCrypto;
     let account: ProtonDriveAccount;
@@ -14,89 +14,89 @@ describe("SharesCryptoService", () => {
         telemetry = getMockTelemetry();
         // @ts-expect-error No need to implement all methods for mocking
         driveCrypto = {
-            decryptKey: jest.fn(async () => Promise.resolve({
-                passphrase: "pass",
-                key: "decryptedKey" as unknown as PrivateKey,
-                passphraseSessionKey: "sessionKey" as unknown as SessionKey,
-                verified: VERIFICATION_STATUS.SIGNED_AND_VALID,
-            })),
+            decryptKey: jest.fn(async () =>
+                Promise.resolve({
+                    passphrase: 'pass',
+                    key: 'decryptedKey' as unknown as PrivateKey,
+                    passphraseSessionKey: 'sessionKey' as unknown as SessionKey,
+                    verified: VERIFICATION_STATUS.SIGNED_AND_VALID,
+                }),
+            ),
         };
         account = {
             // @ts-expect-error No need to implement full response for mocking
             getOwnAddress: jest.fn(async () => ({
-                keys: [{ key: "addressKey" as unknown as PrivateKey }],
+                keys: [{ key: 'addressKey' as unknown as PrivateKey }],
             })),
             getPublicKeys: jest.fn(async () => []),
         };
         cryptoService = new SharesCryptoService(telemetry, driveCrypto, account);
     });
 
-    it("should decrypt root share", async () => {
-        const result = await cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
-        );
+    it('should decrypt root share', async () => {
+        const result = await cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
 
         expect(result).toMatchObject({
             share: {
-                shareId: "shareId",
-                author: { ok: true, value: "signatureEmail" },
+                shareId: 'shareId',
+                author: { ok: true, value: 'signatureEmail' },
             },
             key: {
-                key: "decryptedKey",
-                passphraseSessionKey: "sessionKey",
+                key: 'decryptedKey',
+                passphraseSessionKey: 'sessionKey',
             },
         });
 
-        expect(account.getOwnAddress).toHaveBeenCalledWith("addressId");
-        expect(account.getPublicKeys).toHaveBeenCalledWith("signatureEmail");
+        expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
+        expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
         expect(telemetry.logEvent).not.toHaveBeenCalled();
     });
 
-    it("should decrypt root share with signiture verification error", async () => {
-        driveCrypto.decryptKey = jest.fn(async () => Promise.resolve({
-            passphrase: "pass",
-            key: "decryptedKey" as unknown as PrivateKey,
-            passphraseSessionKey: "sessionKey" as unknown as SessionKey,
-            verified: VERIFICATION_STATUS.NOT_SIGNED,
-        }));
-
-        const result = await cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
+    it('should decrypt root share with signiture verification error', async () => {
+        driveCrypto.decryptKey = jest.fn(async () =>
+            Promise.resolve({
+                passphrase: 'pass',
+                key: 'decryptedKey' as unknown as PrivateKey,
+                passphraseSessionKey: 'sessionKey' as unknown as SessionKey,
+                verified: VERIFICATION_STATUS.NOT_SIGNED,
+            }),
         );
 
+        const result = await cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
+
         expect(result).toMatchObject({
             share: {
-                shareId: "shareId",
-                author: { ok: false, error: { claimedAuthor: "signatureEmail", error: "Missing signature" } },
+                shareId: 'shareId',
+                author: { ok: false, error: { claimedAuthor: 'signatureEmail', error: 'Missing signature' } },
             },
             key: {
-                key: "decryptedKey",
-                passphraseSessionKey: "sessionKey",
+                key: 'decryptedKey',
+                passphraseSessionKey: 'sessionKey',
             },
         });
 
-        expect(account.getOwnAddress).toHaveBeenCalledWith("addressId");
-        expect(account.getPublicKeys).toHaveBeenCalledWith("signatureEmail");
+        expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
+        expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
         expect(telemetry.logEvent).toHaveBeenCalledWith({
             eventName: 'verificationError',
             volumeType: 'own_volume',
@@ -106,23 +106,21 @@ describe("SharesCryptoService", () => {
         });
     });
 
-    it("should handle decrypt issue of root share", async () => {
-        const error = new Error("Decryption error");
+    it('should handle decrypt issue of root share', async () => {
+        const error = new Error('Decryption error');
         driveCrypto.decryptKey = jest.fn(async () => Promise.reject(error));
 
-        const result = cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
-        );
+        const result = cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
 
         await expect(result).rejects.toThrow(error);
 

package/src/internal/shares/cryptoService.ts

@@ -1,16 +1,31 @@
-import { ProtonDriveAccount, resultOk, resultError, Result, UnverifiedAuthorError, ProtonDriveTelemetry, Logger, MetricVolumeType } from "../../interface";
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from "../../crypto";
-import { getVerificationMessage } from "../errors";
-import { EncryptedRootShare, DecryptedRootShare, EncryptedShareCrypto, DecryptedShareKey, ShareType } from "./interface";
+import {
+    ProtonDriveAccount,
+    resultOk,
+    resultError,
+    Result,
+    UnverifiedAuthorError,
+    ProtonDriveTelemetry,
+    Logger,
+    MetricVolumeType,
+} from '../../interface';
+import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
+import { getVerificationMessage } from '../errors';
+import {
+    EncryptedRootShare,
+    DecryptedRootShare,
+    EncryptedShareCrypto,
+    DecryptedShareKey,
+    ShareType,
+} from './interface';
 
 /**
  * Provides crypto operations for share keys.
- * 
+ *
  * The share crypto service is responsible for encrypting and decrypting share
  * keys. It should export high-level actions only, such as "decrypt share"
  * instead of low-level operations like "decrypt share passphrase". Low-level
  * operations should be kept private to the module.
- * 
+ *
  * The service owns the logic to switch between old and new crypto model.
  */
 export class SharesCryptoService {
@@ -19,7 +34,11 @@ export class SharesCryptoService {
     private reportedDecryptionErrors = new Set<string>();
     private reportedVerificationErrors = new Set<string>();
 
-    constructor(private telemetry: ProtonDriveTelemetry, private driveCrypto: DriveCrypto, private account: ProtonDriveAccount) {
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private driveCrypto: DriveCrypto,
+        private account: ProtonDriveAccount,
+    ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLogger('shares-crypto');
         this.driveCrypto = driveCrypto;
@@ -27,16 +46,21 @@ export class SharesCryptoService {
     }
 
     async generateVolumeBootstrap(addressKey: PrivateKey): Promise<{
-        shareKey: { encrypted: EncryptedShareCrypto, decrypted: DecryptedShareKey },
+        shareKey: { encrypted: EncryptedShareCrypto; decrypted: DecryptedShareKey };
         rootNode: {
-            key: { encrypted: EncryptedShareCrypto, decrypted: DecryptedShareKey },
-            encryptedName: string,
-            armoredHashKey: string,
-        }
+            key: { encrypted: EncryptedShareCrypto; decrypted: DecryptedShareKey };
+            encryptedName: string;
+            armoredHashKey: string;
+        };
     }> {
         const shareKey = await this.driveCrypto.generateKey([addressKey], addressKey);
         const rootNodeKey = await this.driveCrypto.generateKey([shareKey.decrypted.key], addressKey);
-        const { armoredNodeName } = await this.driveCrypto.encryptNodeName('root', undefined, shareKey.decrypted.key, addressKey);
+        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(
+            'root',
+            undefined,
+            shareKey.decrypted.key,
+            addressKey,
+        );
         const { armoredHashKey } = await this.driveCrypto.generateHashKey(rootNodeKey.decrypted.key);
         return {
             shareKey,
@@ -45,10 +69,10 @@ export class SharesCryptoService {
                 encryptedName: armoredNodeName,
                 armoredHashKey,
             },
-        }
+        };
     }
 
-    async decryptRootShare(share: EncryptedRootShare): Promise<{ share: DecryptedRootShare, key: DecryptedShareKey }> {
+    async decryptRootShare(share: EncryptedRootShare): Promise<{ share: DecryptedRootShare; key: DecryptedShareKey }> {
         const { keys: addressKeys } = await this.account.getOwnAddress(share.addressId);
         const addressPublicKeys = await this.account.getPublicKeys(share.creatorEmail);
 
@@ -60,7 +84,7 @@ export class SharesCryptoService {
                 share.encryptedCrypto.armoredPassphraseSignature,
                 addressKeys.map(({ key }) => key),
                 addressPublicKeys,
-            )
+            );
             key = result.key;
             passphraseSessionKey = result.passphraseSessionKey;
             verified = result.verified;
@@ -69,12 +93,13 @@ export class SharesCryptoService {
             throw error;
         }
 
-        const author: Result<string, UnverifiedAuthorError> = verified === VERIFICATION_STATUS.SIGNED_AND_VALID
-            ? resultOk(share.creatorEmail)
-            : resultError({
-                claimedAuthor: share.creatorEmail,
-                error: getVerificationMessage(verified),
-            });
+        const author: Result<string, UnverifiedAuthorError> =
+            verified === VERIFICATION_STATUS.SIGNED_AND_VALID
+                ? resultOk(share.creatorEmail)
+                : resultError({
+                      claimedAuthor: share.creatorEmail,
+                      error: getVerificationMessage(verified),
+                  });
 
         if (!author.ok) {
             await this.reportVerificationError(share);
@@ -89,7 +114,7 @@ export class SharesCryptoService {
                 key,
                 passphraseSessionKey,
             },
-        }
+        };
     }
 
     private reportDecryptionError(share: EncryptedRootShare, error?: unknown) {