@protontech/drive-sdk 0.4.0 → 0.5.0

package/src/internal/sharingPublic/apiService.ts

@@ -1,15 +1,11 @@
 import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
 import { Logger, MemberRole } from '../../interface';
-import { makeNodeUid, splitNodeUid } from '../uids';
-import { EncryptedShareCrypto, EncryptedNode } from './interface';
-
-const PAGE_SIZE = 50;
+import { makeNodeUid } from '../uids';
+import { EncryptedNode } from '../nodes/interface';
+import { EncryptedShareCrypto } from './interface';
 
 type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
 
-type GetTokenFolderChildrenResponse =
-    drivePaths['/drive/urls/{token}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
-
 /**
  * Provides API communication for accessing public link data.
  *
@@ -41,27 +37,6 @@ export class SharingPublicAPIService {
             },
         };
     }
-
-    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
-        const { volumeId: token, nodeId } = splitNodeUid(parentUid);
-
-        let page = 0;
-        while (true) {
-            const response = await this.apiService.get<GetTokenFolderChildrenResponse>(
-                `drive/urls/${token}/folders/${nodeId}/children?Page=${page}&PageSize=${PAGE_SIZE}`,
-                signal,
-            );
-
-            for (const link of response.Links) {
-                yield linkToEncryptedNode(this.logger, token, link);
-            }
-
-            if (response.Links.length < PAGE_SIZE) {
-                break;
-            }
-            page++;
-        }
-    }
 }
 
 function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
@@ -70,12 +45,13 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
         encryptedName: token.Name,
 
         // Basic node metadata
-        uid: makeNodeUid(token.Token, token.LinkID),
+        uid: makeNodeUid(token.VolumeID, token.LinkID),
         parentUid: undefined,
         type: nodeTypeNumberToNodeType(logger, token.LinkType),
         creationTime: new Date(), // TODO
 
         isShared: false,
+        isSharedPublicly: false,
         directRole: MemberRole.Viewer, // TODO
     };
 
@@ -114,60 +90,3 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
 
     throw new Error(`Unknown node type: ${token.LinkType}`);
 }
-
-function linkToEncryptedNode(
-    logger: Logger,
-    token: string,
-    link: GetTokenFolderChildrenResponse['Links'][0],
-): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        hash: link.Hash || undefined,
-        encryptedName: link.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token, link.LinkID),
-        parentUid: link.ParentLinkID ? makeNodeUid(token, link.ParentLinkID) : undefined,
-        type: nodeTypeNumberToNodeType(logger, link.Type),
-        creationTime: new Date(), // TODO
-        totalStorageSize: link.TotalSize,
-
-        isShared: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: link.SignatureEmail || undefined,
-        armoredKey: link.NodeKey,
-        armoredNodePassphrase: link.NodePassphrase,
-        armoredNodePassphraseSignature: link.NodePassphraseSignature || undefined,
-    };
-
-    if (link.Type === 1 && link.FolderProperties) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: link.FolderProperties.NodeHashKey as string,
-                },
-            },
-        };
-    }
-
-    if (link.Type === 2 && link.FileProperties?.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: link.FileProperties.ActiveRevision?.Size || undefined,
-            mediaType: link.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: link.FileProperties.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${link.Type}`);
-}

package/src/internal/sharingPublic/cryptoCache.ts

@@ -1,6 +1,5 @@
 import { PrivateKey } from '../../crypto';
 import { ProtonDriveCryptoCache, Logger } from '../../interface';
-import { DecryptedNodeKeys } from './interface';
 
 /**
  * Provides caching for public link crypto material.
@@ -39,41 +38,8 @@ export class SharingPublicCryptoCache {
         }
         return shareKeyData.publicShareKey.key;
     }
-
-    async setNodeKeys(nodeUid: string, keys: DecryptedNodeKeys): Promise<void> {
-        const cacheUid = getNodeCacheKey(nodeUid);
-        await this.driveCache.setEntity(cacheUid, {
-            nodeKeys: keys,
-        });
-    }
-
-    async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
-        const nodeKeysData = await this.driveCache.getEntity(getNodeCacheKey(nodeUid));
-        if (!nodeKeysData.nodeKeys) {
-            try {
-                await this.removeNodeKeys([nodeUid]);
-            } catch (removingError: unknown) {
-                // The node keys will not be returned, thus SDK will re-fetch
-                // and re-cache it. Setting it again should then fix the problem.
-                this.logger.warn(
-                    `Failed to remove corrupted public node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
-                );
-            }
-            throw new Error(`Failed to deserialize public node keys`);
-        }
-        return nodeKeysData.nodeKeys;
-    }
-
-    async removeNodeKeys(nodeUids: string[]): Promise<void> {
-        const cacheUids = nodeUids.map(getNodeCacheKey);
-        await this.driveCache.removeEntities(cacheUids);
-    }
 }
 
 function getShareKeyCacheKey() {
     return 'publicShareKey';
 }
-
-function getNodeCacheKey(nodeUid: string) {
-    return `publicNodeKeys-${nodeUid}`;
-}

package/src/internal/sharingPublic/cryptoReporter.ts

@@ -0,0 +1,73 @@
+import { c } from 'ttag';
+
+import { VERIFICATION_STATUS } from '../../crypto';
+import { getVerificationMessage } from '../errors';
+import {
+    resultOk,
+    resultError,
+    Author,
+    AnonymousUser,
+    ProtonDriveTelemetry,
+    MetricVerificationErrorField,
+    MetricVolumeType,
+    MetricsDecryptionErrorField,
+    Logger,
+} from '../../interface';
+
+export class SharingPublicCryptoReporter {
+    private logger: Logger;
+    private telemetry: ProtonDriveTelemetry;
+
+    constructor(telemetry: ProtonDriveTelemetry) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('sharingPublic-crypto');
+    }
+
+    async handleClaimedAuthor(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys = false,
+    ): Promise<Author> {
+        if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
+            return resultOk(claimedAuthor || (null as AnonymousUser));
+        }
+
+        return resultError({
+            claimedAuthor,
+            error: !claimedAuthor
+                ? c('Info').t`Author is not provided on public link`
+                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+        });
+    }
+
+    reportDecryptionError(
+        node: { uid: string; creationTime: Date },
+        field: MetricsDecryptionErrorField,
+        error: unknown,
+    ) {
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        this.logger.error(
+            `Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`,
+            error,
+        );
+
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType: MetricVolumeType.SharedPublic,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
+    }
+
+    reportVerificationError() {
+        // Authors or signatures are not provided on public links.
+        // We do not report any signature verification errors at this moment.
+    }
+}

package/src/internal/sharingPublic/cryptoService.ts

@@ -1,30 +1,12 @@
-import { c } from 'ttag';
-
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage } from '../errors';
-import {
-    resultOk,
-    resultError,
-    Author,
-    AnonymousUser,
-    ProtonDriveTelemetry,
-    MetricVerificationErrorField,
-    MetricVolumeType,
-    MetricsDecryptionErrorField,
-    Logger,
-    ProtonDriveAccount,
-} from '../../interface';
-import { NodesCryptoService } from '../nodes/cryptoService';
+import { DriveCrypto, PrivateKey } from '../../crypto';
 import { EncryptedShareCrypto } from './interface';
 
-export class SharingPublicCryptoService extends NodesCryptoService {
+export class SharingPublicCryptoService {
     constructor(
-        telemetry: ProtonDriveTelemetry,
-        driveCrypto: DriveCrypto,
-        account: ProtonDriveAccount,
+        private driveCrypto: DriveCrypto,
         private password: string,
     ) {
-        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
+        this.driveCrypto = driveCrypto;
         this.password = password;
     }
 
@@ -38,61 +20,3 @@ export class SharingPublicCryptoService extends NodesCryptoService {
         return shareKey;
     }
 }
-
-class SharingPublicCryptoReporter {
-    private logger: Logger;
-    private telemetry: ProtonDriveTelemetry;
-
-    constructor(telemetry: ProtonDriveTelemetry) {
-        this.telemetry = telemetry;
-        this.logger = telemetry.getLogger('sharingPublic-crypto');
-    }
-
-    async handleClaimedAuthor(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        signatureType: string,
-        verified: VERIFICATION_STATUS,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-        notAvailableVerificationKeys = false,
-    ): Promise<Author> {
-        if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
-            return resultOk(claimedAuthor || (null as AnonymousUser));
-        }
-
-        return resultError({
-            claimedAuthor,
-            error: !claimedAuthor
-                ? c('Info').t`Author is not provided on public link`
-                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
-        });
-    }
-
-    reportDecryptionError(
-        node: { uid: string; creationTime: Date },
-        field: MetricsDecryptionErrorField,
-        error: unknown,
-    ) {
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        this.logger.error(
-            `Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`,
-            error,
-        );
-
-        this.telemetry.recordMetric({
-            eventName: 'decryptionError',
-            volumeType: MetricVolumeType.SharedPublic,
-            field,
-            fromBefore2024,
-            error,
-            uid: node.uid,
-        });
-    }
-
-    reportVerificationError() {
-        // Authors or signatures are not provided on public links.
-        // We do not report any signature verification errors at this moment.
-    }
-}

package/src/internal/sharingPublic/index.ts

@@ -1,10 +1,22 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
+import {
+    ProtonDriveCryptoCache,
+    ProtonDriveTelemetry,
+    ProtonDriveAccount,
+    ProtonDriveEntitiesCache,
+} from '../../interface';
 import { DriveAPIService } from '../apiService';
+import { NodeAPIService } from '../nodes/apiService';
+import { NodesCache } from '../nodes/cache';
+import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesRevisons } from '../nodes/nodesRevisions';
 import { SharingPublicAPIService } from './apiService';
 import { SharingPublicCryptoCache } from './cryptoCache';
+import { SharingPublicCryptoReporter } from './cryptoReporter';
 import { SharingPublicCryptoService } from './cryptoService';
-import { SharingPublicManager } from './manager';
+import { SharingPublicNodesAccess } from './nodes';
+import { SharingPublicSharesManager } from './shares';
 
 export { SharingPublicSessionManager } from './session/manager';
 
@@ -20,22 +32,72 @@ export { SharingPublicSessionManager } from './session/manager';
 export function initSharingPublicModule(
     telemetry: ProtonDriveTelemetry,
     apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
     driveCryptoCache: ProtonDriveCryptoCache,
     driveCrypto: DriveCrypto,
     account: ProtonDriveAccount,
+    url: string,
     token: string,
     password: string,
 ) {
     const api = new SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
     const cryptoCache = new SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
-    const cryptoService = new SharingPublicCryptoService(telemetry, driveCrypto, account, password);
-    const manager = new SharingPublicManager(
-        telemetry.getLogger('sharingPublic-nodes'),
+    const cryptoService = new SharingPublicCryptoService(driveCrypto, password);
+    const shares = new SharingPublicSharesManager(api, cryptoCache, cryptoService, account, token);
+    const nodes = initSharingPublicNodesModule(
+        telemetry,
+        apiService,
+        driveEntitiesCache,
+        driveCryptoCache,
+        driveCrypto,
+        account,
+        shares,
+        url,
+        token,
+    );
+
+    return {
+        shares,
+        nodes,
+    };
+}
+
+/**
+ * Provides facade for the public link nodes module.
+ *
+ * The public link nodes initializes the core nodes module, but uses public
+ * link shares or crypto reporter instead.
+ */
+export function initSharingPublicNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    driveCrypto: DriveCrypto,
+    account: ProtonDriveAccount,
+    sharesService: SharingPublicSharesManager,
+    url: string,
+    token: string,
+) {
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
+    const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
+    const cryptoReporter = new SharingPublicCryptoReporter(telemetry);
+    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
+    const nodesAccess = new SharingPublicNodesAccess(
+        telemetry.getLogger('nodes'),
         api,
+        cache,
         cryptoCache,
         cryptoService,
+        sharesService,
+        url,
         token,
     );
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
-    return manager;
+    return {
+        access: nodesAccess,
+        revisions: nodesRevisions,
+    };
 }

package/src/internal/sharingPublic/interface.ts

@@ -1,12 +1,3 @@
-// TODO: use them directly, or avoid them completely
-export type {
-    EncryptedNode,
-    EncryptedNodeFolderCrypto,
-    EncryptedNodeFileCrypto,
-    DecryptedNode,
-    DecryptedNodeKeys,
-} from '../nodes/interface';
-
 export interface EncryptedShareCrypto {
     base64UrlPasswordSalt: string;
     armoredKey: string;

package/src/internal/sharingPublic/nodes.ts

@@ -0,0 +1,37 @@
+import { Logger } 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 { isProtonDocument, isProtonSheet } from "../nodes/mediaTypes";
+import { splitNodeUid } from "../uids";
+import { SharingPublicSharesManager } from "./shares";
+
+export class SharingPublicNodesAccess extends NodesAccess {
+    constructor(
+        logger: Logger,
+        apiService: NodeAPIService,
+        cache: NodesCache,
+        cryptoCache: NodesCryptoCache,
+        cryptoService: NodesCryptoService,
+        sharesService: SharingPublicSharesManager,
+        private url: string,
+        private token: string,
+    ) {
+        super(logger, apiService, cache, cryptoCache, cryptoService, sharesService);
+        this.token = token;
+    }
+
+    async getNodeUrl(nodeUid: string): Promise<string> {
+        const node = await this.getNode(nodeUid);
+        if (isProtonDocument(node.mediaType) || isProtonSheet(node.mediaType)) {
+            const { nodeId } = splitNodeUid(nodeUid);
+            const type = isProtonDocument(node.mediaType) ? 'doc' : 'sheet';
+            return `https://docs.proton.me/doc?type=${type}&mode=open-url&token=${this.token}&linkId=${nodeId}`;
+        }
+
+        // Public link doesn't support specific node URLs.
+        return this.url;
+    }
+}

package/src/internal/sharingPublic/session/apiService.ts

@@ -9,7 +9,7 @@ type PostPublicLinkAuthRequest = Extract<
     { content: object }
 >['content']['application/json'];
 type PostPublicLinkAuthResponse =
-        drivePaths['/drive/urls/{token}/auth']['post']['responses']['200']['content']['application/json'];
+    drivePaths['/drive/urls/{token}/auth']['post']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for managing public link session (not data).

package/src/internal/sharingPublic/session/session.ts

@@ -1,6 +1,6 @@
-import { SRPModule } from "../../../crypto";
-import { SharingPublicSessionAPIService } from "./apiService";
-import { PublicLinkInfo, PublicLinkSrpInfo } from "./interface";
+import { SRPModule } from '../../../crypto';
+import { SharingPublicSessionAPIService } from './apiService';
+import { PublicLinkInfo, PublicLinkSrpInfo } from './interface';
 
 /**
  * Session for a public link.

package/src/internal/sharingPublic/session/url.test.ts

@@ -9,7 +9,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'abc123',
-                password: 'def456'
+                password: 'def456',
             });
         });
 
@@ -19,7 +19,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'mytoken',
-                password: 'mypassword'
+                password: 'mypassword',
             });
         });
 
@@ -29,7 +29,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'token123',
-                password: 'password456'
+                password: 'password456',
             });
         });
     });

package/src/internal/sharingPublic/shares.ts

@@ -0,0 +1,86 @@
+import { PrivateKey } from '../../crypto';
+import { MetricVolumeType, ProtonDriveAccount } from '../../interface';
+import { splitNodeUid } from '../uids';
+import { SharingPublicAPIService } from './apiService';
+import { SharingPublicCryptoCache } from './cryptoCache';
+import { SharingPublicCryptoService } from './cryptoService';
+
+/**
+ * Provides high-level actions for managing public link share.
+ *
+ * The public link share manager provides the same interface as the code share
+ * service so it can be used in the same way in various modules that use shares.
+ */
+export class SharingPublicSharesManager {
+    private promisePublicLinkRoot?: Promise<{
+        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
+        shareKey: PrivateKey;
+    }>;
+
+    constructor(
+        private apiService: SharingPublicAPIService,
+        private cryptoCache: SharingPublicCryptoCache,
+        private cryptoService: SharingPublicCryptoService,
+        private account: ProtonDriveAccount,
+        private token: string,
+    ) {
+        this.apiService = apiService;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.account = account;
+        this.token = token;
+    }
+
+    // TODO: Rename to getRootIDs everywhere.
+    async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
+        const { rootIds } = await this.getPublicLinkRoot();
+        return rootIds;
+    }
+
+    async getSharePrivateKey(): Promise<PrivateKey> {
+        const { shareKey } = await this.getPublicLinkRoot();
+        return shareKey;
+    }
+
+    private async getPublicLinkRoot(): Promise<{
+        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
+        shareKey: PrivateKey;
+    }> {
+        if (!this.promisePublicLinkRoot) {
+            this.promisePublicLinkRoot = (async () => {
+                const { encryptedNode, encryptedShare } = await this.apiService.getPublicLinkRoot(this.token);
+
+                const { volumeId, nodeId: rootNodeId } = splitNodeUid(encryptedNode.uid);
+
+                const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
+                await this.cryptoCache.setShareKey(shareKey);
+
+                return {
+                    rootIds: { volumeId, rootNodeId, rootNodeUid: encryptedNode.uid },
+                    shareKey,
+                };
+            })();
+        }
+
+        return this.promisePublicLinkRoot;
+    }
+
+    async getContextShareMemberEmailKey(): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }> {
+        const address = await this.account.getOwnPrimaryAddress();
+        return {
+            email: address.email,
+            addressId: address.addressId,
+            addressKey: address.keys[address.primaryKeyIndex].key,
+            addressKeyId: address.keys[address.primaryKeyIndex].id,
+        };
+    }
+
+    async getVolumeMetricContext(): Promise<MetricVolumeType> {
+        return MetricVolumeType.SharedPublic;
+    }
+}

package/src/internal/upload/apiService.ts

@@ -53,8 +53,8 @@ type PostDeleteNodesResponse =
 
 export class UploadAPIService {
     constructor(
-        private apiService: DriveAPIService,
-        private clientUid: string | undefined,
+        protected apiService: DriveAPIService,
+        protected clientUid: string | undefined,
     ) {
         this.apiService = apiService;
         this.clientUid = clientUid;
@@ -110,6 +110,17 @@ export class UploadAPIService {
         nodeUid: string;
         nodeRevisionUid: string;
     }> {
+        // The client shouldn't send the clear text size of the file.
+        // The intented upload size is needed only for early validation that
+        // the file can fit in the remaining quota to avoid data transfer when
+        // the upload would be rejected. The backend will still validate
+        // the quota during block upload and revision commit.
+        const precision = 100_000; // bytes
+        const intendedUploadSize =
+            node.intendedUploadSize && node.intendedUploadSize > precision
+                ? Math.floor(node.intendedUploadSize / precision) * precision
+                : null;
+
         const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
         const result = await this.apiService.post<PostCreateDraftRequest, PostCreateDraftResponse>(
             `drive/v2/volumes/${volumeId}/files`,
@@ -119,7 +130,7 @@ export class UploadAPIService {
                 Hash: node.hash,
                 MIMEType: node.mediaType,
                 ClientUID: this.clientUid || null,
-                IntendedUploadSize: node.intendedUploadSize || null,
+                IntendedUploadSize: intendedUploadSize,
                 NodeKey: node.armoredNodeKey,
                 NodePassphrase: node.armoredNodePassphrase,
                 NodePassphraseSignature: node.armoredNodePassphraseSignature,
@@ -252,7 +263,7 @@ export class UploadAPIService {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
             XAttr: options.armoredExtendedAttributes || null,
-            Photo: null, // TODO
+            Photo: null, // Only used for photos in the Photo volume.
         });
     }