@protontech/drive-sdk 0.6.1 → 0.7.0

package/src/internal/nodes/interface.ts

@@ -10,6 +10,7 @@ import {
     MetricVolumeType,
     Revision,
     RevisionState,
+    AnonymousUser,
 } from '../../interface';
 
 export type FilterOptions = {
@@ -57,8 +58,8 @@ export interface EncryptedNode extends BaseNode {
 }
 
 export interface EncryptedNodeCrypto {
-    signatureEmail?: string;
-    nameSignatureEmail?: string;
+    signatureEmail?: string | AnonymousUser;
+    nameSignatureEmail?: string | AnonymousUser;
     armoredKey: string;
     armoredNodePassphrase: string;
     armoredNodePassphraseSignature?: string;
@@ -88,6 +89,19 @@ export interface EncryptedNodeFolderCrypto extends EncryptedNodeCrypto {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface EncryptedNodeAlbumCrypto extends EncryptedNodeCrypto {}
 
+export type NodeSigningKeys =
+    | {
+          type: 'userAddress';
+          email: string;
+          addressId: string;
+          key: PrivateKey;
+      }
+    | {
+          type: 'nodeKey';
+          nodeKey?: PrivateKey;
+          parentNodeKey?: PrivateKey;
+      };
+
 /**
  * Interface used only internally in the nodes module.
  *

package/src/internal/nodes/nodesAccess.ts

@@ -29,6 +29,7 @@ import {
     DecryptedNode,
     DecryptedNodeKeys,
     FilterOptions,
+    NodeSigningKeys,
 } from './interface';
 import { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
@@ -425,6 +426,22 @@ export class NodesAccess {
         };
     }
 
+    async getNodeSigningKeys(
+        uids: { nodeUid: string; parentNodeUid?: string } | { nodeUid?: string; parentNodeUid: string },
+    ): Promise<NodeSigningKeys> {
+        const contextNodeUid = uids.nodeUid || uids.parentNodeUid;
+        if (!contextNodeUid) {
+            throw new Error('Context node UID is required for signing keys');
+        }
+        const address = await this.getRootNodeEmailKey(contextNodeUid);
+        return {
+            type: 'userAddress',
+            email: address.email,
+            addressId: address.addressId,
+            key: address.addressKey,
+        };
+    }
+
     async getRootNodeEmailKey(nodeUid: string): Promise<{
         email: string;
         addressId: string;

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

@@ -57,7 +57,7 @@ describe('NodesManagement', () => {
             restoreNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
-            deleteNodes: jest.fn(async function* (uids) {
+            deleteTrashedNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             createFolder: jest.fn(),
@@ -117,7 +117,12 @@ describe('NodesManagement', () => {
                     nameSessionKey: `${uid}-nameSessionKey`,
                 }),
             ),
-            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'root-email', addressKey: 'root-key' }),
+            getNodeSigningKeys: jest.fn().mockResolvedValue({
+                type: 'userAddress',
+                email: 'root-email',
+                addressId: 'root-addressId',
+                key: 'root-key',
+            }),
             notifyNodeChanged: jest.fn(),
             notifyNodeDeleted: jest.fn(),
             notifyChildCreated: jest.fn(),
@@ -136,11 +141,11 @@ describe('NodesManagement', () => {
             nameAuthor: { ok: true, value: 'newSignatureEmail' },
             hash: 'newHash',
         });
-        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('nodeUid');
+        expect(nodesAccess.getNodeSigningKeys).toHaveBeenCalledWith({ nodeUid: 'nodeUid', parentNodeUid: 'parentUid' });
         expect(cryptoService.encryptNewName).toHaveBeenCalledWith(
             { key: 'parentUid-key', hashKey: 'parentUid-hashKey' },
             'nodeUid-nameSessionKey',
-            { email: 'root-email', addressKey: 'root-key' },
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
             'new name',
         );
         expect(apiService.renameNode).toHaveBeenCalledWith(
@@ -181,7 +186,10 @@ describe('NodesManagement', () => {
             keyAuthor: { ok: true, value: 'movedSignatureEmail' },
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
         });
-        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
+        expect(nodesAccess.getNodeSigningKeys).toHaveBeenCalledWith({
+            nodeUid: 'nodeUid',
+            parentNodeUid: 'newParentNodeUid',
+        });
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.nodeUid,
             expect.objectContaining({
@@ -192,7 +200,7 @@ describe('NodesManagement', () => {
                 nameSessionKey: 'nodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: 'root-email', addressKey: 'root-key' },
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
         );
         expect(apiService.moveNode).toHaveBeenCalledWith(
             'nodeUid',
@@ -232,7 +240,7 @@ describe('NodesManagement', () => {
                 nameSessionKey: 'anonymousNodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: 'root-email', addressKey: 'root-key' },
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
@@ -276,7 +284,10 @@ describe('NodesManagement', () => {
             keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
             nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
         });
-        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
+        expect(nodesAccess.getNodeSigningKeys).toHaveBeenCalledWith({
+            nodeUid: 'nodeUid',
+            parentNodeUid: 'newParentNodeUid',
+        });
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.nodeUid,
             expect.objectContaining({
@@ -287,7 +298,7 @@ describe('NodesManagement', () => {
                 nameSessionKey: 'nodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: 'root-email', addressKey: 'root-key' },
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
         );
         expect(apiService.copyNode).toHaveBeenCalledWith('nodeUid', {
             parentUid: 'newParentNodeUid',
@@ -322,7 +333,7 @@ describe('NodesManagement', () => {
                 nameSessionKey: 'anonymousNodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: 'root-email', addressKey: 'root-key' },
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,

package/src/internal/nodes/nodesManagement.ts

@@ -28,10 +28,10 @@ const AVAILABLE_NAME_LIMIT = 1000;
  */
 export class NodesManagement {
     constructor(
-        private apiService: NodeAPIService,
-        private cryptoCache: NodesCryptoCache,
-        private cryptoService: NodesCryptoService,
-        private nodesAccess: NodesAccess,
+        protected apiService: NodeAPIService,
+        protected cryptoCache: NodesCryptoCache,
+        protected cryptoService: NodesCryptoService,
+        protected nodesAccess: NodesAccess,
     ) {
         this.apiService = apiService;
         this.cryptoCache = cryptoCache;
@@ -49,7 +49,7 @@ export class NodesManagement {
         const node = await this.nodesAccess.getNode(nodeUid);
         const { nameSessionKey: nodeNameSessionKey } = await this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid);
         const parentKeys = await this.nodesAccess.getParentKeys(node);
-        const address = await this.nodesAccess.getRootNodeEmailKey(nodeUid);
+        const signingKeys = await this.nodesAccess.getNodeSigningKeys({ nodeUid, parentNodeUid: node.parentUid });
 
         if (!options.allowRenameRootNode && (!node.hash || !parentKeys.hashKey)) {
             throw new ValidationError(c('Error').t`Renaming root item is not allowed`);
@@ -58,7 +58,7 @@ export class NodesManagement {
         const { signatureEmail, armoredNodeName, hash } = await this.cryptoService.encryptNewName(
             parentKeys,
             nodeNameSessionKey,
-            address,
+            signingKeys,
             newName,
         );
 
@@ -95,7 +95,7 @@ export class NodesManagement {
             ...node,
             name: resultOk(newName),
             encryptedName: armoredNodeName,
-            nameAuthor: resultOk(signatureEmail),
+            nameAuthor: resultOk(signatureEmail || null),
             hash,
         };
         return newNode;
@@ -124,14 +124,12 @@ export class NodesManagement {
     }
 
     async moveNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
-        const [node, address] = await Promise.all([
-            this.nodesAccess.getNode(nodeUid),
-            this.nodesAccess.getRootNodeEmailKey(newParentUid),
-        ]);
+        const node = await this.nodesAccess.getNode(nodeUid);
 
-        const [keys, newParentKeys] = await Promise.all([
+        const [keys, newParentKeys, signingKeys] = await Promise.all([
             this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid),
             this.nodesAccess.getNodeKeys(newParentUid),
+            this.nodesAccess.getNodeSigningKeys({ nodeUid, parentNodeUid: newParentUid }),
         ]);
 
         if (!node.hash) {
@@ -145,7 +143,7 @@ export class NodesManagement {
             node,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
-            address,
+            signingKeys,
         );
 
         // Node could be uploaded or renamed by anonymous user and thus have
@@ -214,14 +212,12 @@ export class NodesManagement {
     }
 
     async copyNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
-        const [node, address] = await Promise.all([
-            this.nodesAccess.getNode(nodeUid),
-            this.nodesAccess.getRootNodeEmailKey(newParentUid),
-        ]);
+        const node = await this.nodesAccess.getNode(nodeUid);
 
-        const [keys, newParentKeys] = await Promise.all([
+        const [keys, newParentKeys, signingKeys] = await Promise.all([
             this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid),
             this.nodesAccess.getNodeKeys(newParentUid),
+            this.nodesAccess.getNodeSigningKeys({ nodeUid, parentNodeUid: newParentUid }),
         ]);
 
         if (!newParentKeys.hashKey) {
@@ -232,7 +228,7 @@ export class NodesManagement {
             node,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
-            address,
+            signingKeys,
         );
 
         // Node could be uploaded or renamed by anonymous user and thus have
@@ -286,7 +282,7 @@ export class NodesManagement {
     }
 
     async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        for await (const result of this.apiService.deleteNodes(nodeUids, signal)) {
+        for await (const result of this.apiService.deleteTrashedNodes(nodeUids, signal)) {
             if (result.ok) {
                 await this.nodesAccess.notifyNodeDeleted(result.uid);
             }
@@ -303,12 +299,12 @@ export class NodesManagement {
             throw new ValidationError(c('Error').t`Creating folders in non-folders is not allowed`);
         }
 
-        const address = await this.nodesAccess.getRootNodeEmailKey(parentNodeUid);
+        const signingKeys = await this.nodesAccess.getNodeSigningKeys({ parentNodeUid });
         const extendedAttributes = generateFolderExtendedAttributes(modificationTime);
 
         const { encryptedCrypto, keys } = await this.cryptoService.createFolder(
             { key: parentKeys.key, hashKey: parentKeys.hashKey },
-            address,
+            signingKeys,
             folderName,
             extendedAttributes,
         );
@@ -344,8 +340,8 @@ export class NodesManagement {
 
             // Decrypted metadata
             isStale: false,
-            keyAuthor: resultOk(encryptedCrypto.signatureEmail),
-            nameAuthor: resultOk(encryptedCrypto.signatureEmail),
+            keyAuthor: resultOk(encryptedCrypto.signatureEmail || null),
+            nameAuthor: resultOk(encryptedCrypto.signatureEmail || null),
             name: resultOk(folderName),
             treeEventScopeId: splitNodeUid(nodeUid).volumeId,
         };

package/src/internal/photos/upload.ts

@@ -1,5 +1,5 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveTelemetry, UploadMetadata, Thumbnail } from '../../interface';
+import { ProtonDriveTelemetry, UploadMetadata, Thumbnail, AnonymousUser } from '../../interface';
 import { DriveAPIService, drivePaths } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
 import { splitNodeRevisionUid } from '../uids';
@@ -198,7 +198,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
         draftNodeRevisionUid: string,
         options: {
             armoredManifestSignature: string;
-            signatureEmail: string;
+            signatureEmail: string | AnonymousUser;
             armoredExtendedAttributes?: string;
         },
         photo: {
@@ -220,7 +220,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             XAttr: options.armoredExtendedAttributes || null,
             Photo: {
                 ContentHash: photo.contentHash,
-                CaptureTime: photo.captureTime?.getTime() || 0,
+                CaptureTime: photo.captureTime ? Math.floor(photo.captureTime?.getTime() / 1000) : 0,
                 MainPhotoLinkID: photo.mainPhotoLinkID || null,
                 Tags: photo.tags || [],
                 Exif: null, // Deprecated field, not used.

package/src/internal/sharingPublic/index.ts

@@ -10,13 +10,13 @@ import { NodeAPIService } from '../nodes/apiService';
 import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
-import { NodesManagement } from '../nodes/nodesManagement';
 import { NodesRevisons } from '../nodes/nodesRevisions';
 import { SharingPublicCryptoReporter } from './cryptoReporter';
-import { SharingPublicNodesAccess } from './nodes';
+import { SharingPublicNodesAccess, SharingPublicNodesManagement } from './nodes';
 import { SharingPublicSharesManager } from './shares';
 
 export { SharingPublicSessionManager } from './session/manager';
+export { UnauthDriveAPIService } from './unauthApiService';
 
 /**
  * Provides facade for the whole sharing public module.
@@ -38,6 +38,7 @@ export function initSharingPublicModule(
     token: string,
     publicShareKey: PrivateKey,
     publicRootNodeUid: string,
+    isAnonymousContext: boolean,
 ) {
     const shares = new SharingPublicSharesManager(account, publicShareKey, publicRootNodeUid);
     const nodes = initSharingPublicNodesModule(
@@ -52,6 +53,7 @@ export function initSharingPublicModule(
         token,
         publicShareKey,
         publicRootNodeUid,
+        isAnonymousContext,
     );
 
     return {
@@ -78,6 +80,7 @@ export function initSharingPublicNodesModule(
     token: string,
     publicShareKey: PrivateKey,
     publicRootNodeUid: string,
+    isAnonymousContext: boolean,
 ) {
     const clientUid = undefined; // No client UID for public context yet.
     const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
@@ -96,8 +99,9 @@ export function initSharingPublicNodesModule(
         token,
         publicShareKey,
         publicRootNodeUid,
+        isAnonymousContext,
     );
-    const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
+    const nodesManagement = new SharingPublicNodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
     return {

package/src/internal/sharingPublic/nodes.ts

@@ -1,13 +1,14 @@
-import { ProtonDriveTelemetry } from '../../interface';
+import { NodeResult, ProtonDriveTelemetry } from '../../interface';
 import { NodeAPIService } from '../nodes/apiService';
 import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
 import { NodesAccess } from '../nodes/nodesAccess';
+import { NodesManagement } from '../nodes/nodesManagement';
 import { isProtonDocument, isProtonSheet } from '../nodes/mediaTypes';
 import { splitNodeUid } from '../uids';
 import { SharingPublicSharesManager } from './shares';
-import { DecryptedNode, DecryptedNodeKeys } from '../nodes/interface';
+import { DecryptedNode, DecryptedNodeKeys, NodeSigningKeys } from '../nodes/interface';
 import { PrivateKey } from '../../crypto';
 
 export class SharingPublicNodesAccess extends NodesAccess {
@@ -22,11 +23,13 @@ export class SharingPublicNodesAccess extends NodesAccess {
         private token: string,
         private publicShareKey: PrivateKey,
         private publicRootNodeUid: string,
+        private isAnonymousContext: boolean,
     ) {
         super(telemetry, apiService, cache, cryptoCache, cryptoService, sharesService);
         this.token = token;
         this.publicShareKey = publicShareKey;
         this.publicRootNodeUid = publicRootNodeUid;
+        this.isAnonymousContext = isAnonymousContext;
     }
 
     async getParentKeys(
@@ -56,4 +59,42 @@ export class SharingPublicNodesAccess extends NodesAccess {
         // Public link doesn't support specific node URLs.
         return this.url;
     }
+
+    async getNodeSigningKeys(
+        uids: { nodeUid: string; parentNodeUid?: string } | { nodeUid?: string; parentNodeUid: string },
+    ): Promise<NodeSigningKeys> {
+        if (this.isAnonymousContext) {
+            const nodeKeys = uids.nodeUid ? await this.getNodeKeys(uids.nodeUid) : { key: undefined };
+            const parentNodeKeys = uids.parentNodeUid ? await this.getNodeKeys(uids.parentNodeUid) : { key: undefined };
+            return {
+                type: 'nodeKey',
+                nodeKey: nodeKeys.key,
+                parentNodeKey: parentNodeKeys.key,
+            };
+        }
+
+        return super.getNodeSigningKeys(uids);
+    }
+}
+
+export class SharingPublicNodesManagement extends NodesManagement {
+    constructor(
+        apiService: NodeAPIService,
+        cryptoCache: NodesCryptoCache,
+        cryptoService: NodesCryptoService,
+        nodesAccess: SharingPublicNodesAccess,
+    ) {
+        super(apiService, cryptoCache, cryptoService, nodesAccess);
+    }
+
+    async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        // Public link does not support trashing and deleting trashed nodes.
+        // Instead, if user is owner, API allows directly deleting existing nodes.
+        for await (const result of this.apiService.deleteExistingNodes(nodeUids, signal)) {
+            if (result.ok) {
+                await this.nodesAccess.notifyNodeDeleted(result.uid);
+            }
+            yield result;
+        }
+    }
 }

package/src/internal/sharingPublic/unauthApiService.test.ts

@@ -0,0 +1,29 @@
+import { getUnauthEndpoint } from './unauthApiService';
+
+describe('getUnauthEndpoint', () => {
+    it('should not change urls endpoints', () => {
+        expect(getUnauthEndpoint('drive/urls/anything')).toBe('drive/urls/anything');
+        expect(getUnauthEndpoint('drive/urls/drive/anything')).toBe('drive/urls/drive/anything');
+        expect(getUnauthEndpoint('drive/urls/drive/v2/anything')).toBe('drive/urls/drive/v2/anything');
+    });
+
+    it('should not change v2/urls endpoints', () => {
+        expect(getUnauthEndpoint('drive/v2/urls/anything')).toBe('drive/v2/urls/anything');
+        expect(getUnauthEndpoint('drive/v2/urls/drive/anything')).toBe('drive/v2/urls/drive/anything');
+        expect(getUnauthEndpoint('drive/v2/urls/drive/v2/anything')).toBe('drive/v2/urls/drive/v2/anything');
+    });
+
+    it('should put unauth prefix for v2 endpoints', () => {
+        expect(getUnauthEndpoint('drive/v2/anything')).toBe('drive/unauth/v2/anything');
+        expect(getUnauthEndpoint('drive/v2/drive/anything')).toBe('drive/unauth/v2/drive/anything');
+        expect(getUnauthEndpoint('drive/v2/drive/v2/anything')).toBe('drive/unauth/v2/drive/v2/anything');
+    });
+
+    it('should put unauth prefix for non-v2 endpoints', () => {
+        expect(getUnauthEndpoint('drive/anything')).toBe('drive/unauth/anything');
+        expect(getUnauthEndpoint('drive/anything/v2/anything')).toBe('drive/unauth/anything/v2/anything');
+        expect(getUnauthEndpoint('drive/anything/drive/anything')).toBe('drive/unauth/anything/drive/anything');
+        expect(getUnauthEndpoint('drive/anything/drive/v2/anything')).toBe('drive/unauth/anything/drive/v2/anything');
+    });
+});
+

package/src/internal/sharingPublic/unauthApiService.ts

@@ -0,0 +1,32 @@
+import { DriveAPIService } from '../apiService';
+
+/**
+ * Drive API Service for public links.
+ *
+ * This service is used to make requests to the Drive API without
+ * authentication. The unauth context uses the same endpoint, but
+ * with an `unauth` prefix. The goal is to avoid the need to use
+ * different path and use the exact endpoint for both contexts.
+ * However, API has global logic for handling expired sessions that
+ * is not compatible with the unauth context. For this reason, this
+ * service is used to make requests to the Drive API for public
+ * link context in the mean time.
+ */
+export class UnauthDriveAPIService extends DriveAPIService {
+    protected async makeRequest<RequestPayload, ResponsePayload>(
+        url: string,
+        method = 'GET',
+        data?: RequestPayload,
+        signal?: AbortSignal,
+    ): Promise<ResponsePayload> {
+        const unauthUrl = getUnauthEndpoint(url);
+        return super.makeRequest(unauthUrl, method, data, signal);
+    }
+}
+
+export function getUnauthEndpoint(url: string): string {
+    if (url.startsWith('drive/urls/') || url.startsWith('drive/v2/urls/')) {
+        return url;
+    }
+    return url.replace(/^drive\//, 'drive/unauth/');
+}

package/src/internal/upload/apiService.ts

@@ -1,6 +1,7 @@
 import { c } from 'ttag';
 
 import { base64StringToUint8Array, uint8ArrayToBase64String } from '../../crypto';
+import { AnonymousUser } from '../../interface';
 import { APICodeError, DriveAPIService, drivePaths, isCodeOk } from '../apiService';
 import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid } from '../uids';
 import { UploadTokens } from './interface';
@@ -65,7 +66,7 @@ export class UploadAPIService {
             armoredNodePassphraseSignature: string;
             base64ContentKeyPacket: string;
             armoredContentKeyPacketSignature: string;
-            signatureEmail: string;
+            signatureEmail: string | AnonymousUser;
         },
     ): Promise<{
         nodeUid: string;
@@ -150,7 +151,7 @@ export class UploadAPIService {
 
     async requestBlockUpload(
         draftNodeRevisionUid: string,
-        addressId: string,
+        addressId: string | AnonymousUser,
         blocks: {
             contentBlocks: {
                 index: number;
@@ -211,7 +212,7 @@ export class UploadAPIService {
         draftNodeRevisionUid: string,
         options: {
             armoredManifestSignature: string;
-            signatureEmail: string;
+            signatureEmail: string | AnonymousUser;
             armoredExtendedAttributes?: string;
         },
     ): Promise<void> {