@autonomys/auto-drive 0.7.2 → 0.7.4

package/dist/ipld/builders.d.ts

@@ -1,10 +1,11 @@
 import { CID } from 'multiformats/cid';
 import { PBNode } from '../ipld/index.js';
+import { FileUploadOptions } from '../metadata/index.js';
 export interface Builders {
     inlink: (links: CID[], size: number, linkDepth: number, chunkSize: number) => PBNode;
     chunk: (data: Buffer) => PBNode;
-    root: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number) => PBNode;
-    single: (data: Buffer, filename?: string) => PBNode;
+    root: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number, fileUploadOptions?: FileUploadOptions) => PBNode;
+    single: (data: Buffer, filename?: string, fileUploadOptions?: FileUploadOptions) => PBNode;
 }
 export declare const metadataBuilders: Builders;
 export declare const fileBuilders: Builders;

package/dist/ipld/builders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/ipld/builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAYzC,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACpF,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/B,IAAI,EAAE,CACJ,KAAK,EAAE,GAAG,EAAE,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,KACjB,MAAM,CAAA;IACX,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CACpD;AACD,eAAO,MAAM,gBAAgB,EAAE,QAK9B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,QAK1B,CAAA"}
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/ipld/builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAYxD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACpF,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/B,IAAI,EAAE,CACJ,KAAK,EAAE,GAAG,EAAE,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,iBAAiB,CAAC,EAAE,iBAAiB,KAClC,MAAM,CAAA;IACX,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,KAAK,MAAM,CAAA;CAC3F;AACD,eAAO,MAAM,gBAAgB,EAAE,QAK9B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,QAK1B,CAAA"}

package/dist/ipld/chunker.d.ts

@@ -1,26 +1,23 @@
 import type { BaseBlockstore } from 'blockstore-core';
 import type { AwaitIterable } from 'interface-store';
 import { CID } from 'multiformats';
-import { OffchainMetadata } from '../metadata/index.js';
+import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js';
 import { Builders } from './builders.js';
 import { PBNode } from './utils.js';
-export declare const DEFAULT_MAX_CHUNK_SIZE: number;
-export declare const DEFAULT_MAX_LINK_PER_NODE: number;
-export declare const processFileToIPLDFormat: (blockstore: BaseBlockstore, file: AwaitIterable<Buffer>, totalSize: number, filename?: string, { maxChunkSize, maxLinkPerNode }?: {
+type ChunkerLimits = {
     maxChunkSize: number;
     maxLinkPerNode: number;
-}) => Promise<CID>;
+};
+type ChunkerOptions = ChunkerLimits & FileUploadOptions;
+export declare const DEFAULT_MAX_CHUNK_SIZE: number;
+export declare const DEFAULT_MAX_LINK_PER_NODE: number;
+export declare const processFileToIPLDFormat: (blockstore: BaseBlockstore, file: AwaitIterable<Buffer>, totalSize: number, filename?: string, { maxChunkSize, maxLinkPerNode, encryption, compression, }?: Partial<ChunkerOptions>) => Promise<CID>;
 export declare const processMetadataToIPLDFormat: (blockstore: BaseBlockstore, metadata: OffchainMetadata, limits?: {
     maxChunkSize: number;
     maxLinkPerNode: number;
 }) => Promise<CID>;
-export declare const processBufferToIPLDFormatFromChunks: (blockstore: BaseBlockstore, chunks: AwaitIterable<CID>, filename: string | undefined, totalSize: number, builders: Builders, { maxLinkPerNode, maxChunkSize }?: {
-    maxLinkPerNode: number;
-    maxChunkSize: number;
-}) => Promise<CID>;
-export declare const processFolderToIPLDFormat: (blockstore: BaseBlockstore, children: CID[], name: string, size: number, { maxLinkPerNode }?: {
-    maxLinkPerNode: number;
-}) => Promise<CID>;
+export declare const processBufferToIPLDFormatFromChunks: (blockstore: BaseBlockstore, chunks: AwaitIterable<CID>, filename: string | undefined, totalSize: number, builders: Builders, { maxChunkSize, maxLinkPerNode, encryption, compression, }?: Partial<ChunkerOptions>) => Promise<CID>;
+export declare const processFolderToIPLDFormat: (blockstore: BaseBlockstore, children: CID[], name: string, size: number, { maxLinkPerNode, maxChunkSize, compression, encryption, }?: Partial<ChunkerOptions>) => Promise<CID>;
 /**
  * Process chunks to IPLD format, return the last chunk if it's not full
  * @returns the last chunk if it's not full, otherwise an empty buffer
@@ -29,4 +26,5 @@ export declare const processChunksToIPLDFormat: (blockstore: BaseBlockstore, chu
     maxChunkSize?: number;
 }) => Promise<Buffer>;
 export declare const ensureNodeMaxSize: (node: PBNode, maxSize?: number) => PBNode;
+export {};
 //# sourceMappingURL=chunker.d.ts.map

package/dist/ipld/chunker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/ipld/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAsB,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,EAAE,QAAQ,EAAkC,MAAM,eAAe,CAAA;AAExE,OAAO,EAA2B,MAAM,EAAE,MAAM,YAAY,CAAA;AAE5D,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAG/C,eAAO,MAAM,yBAAyB,QAAwD,CAAA;AAE9F,eAAO,MAAM,uBAAuB,eACtB,cAAc,QACpB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,aACN,MAAM,qCACiB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAIjF,OAAO,CAAC,GAAG,CAKb,CAAA;AAED,eAAO,MAAM,2BAA2B,eAC1B,cAAc,YAChB,gBAAgB,WAClB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAIvD,OAAO,CAAC,GAAG,CAab,CAAA;AA6BD,eAAO,MAAM,mCAAmC,eAClC,cAAc,UAClB,aAAa,CAAC,GAAG,CAAC,YAChB,MAAM,GAAG,SAAS,aACjB,MAAM,YACP,QAAQ,qCACgB;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,KAIjF,OAAO,CAAC,GAAG,CAsCb,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,cAAc,YAChB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,uBACQ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,KAC7C,OAAO,CAAC,GAAG,CAqBb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,eACxB,cAAc,UAClB,aAAa,CAAC,MAAM,CAAC,YACnB,QAAQ,oBACyB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACnE,OAAO,CAAC,MAAM,CAchB,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACH,MAAM,KACd,MAOF,CAAA"}
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/ipld/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAsB,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC9F,OAAO,EAAE,QAAQ,EAAkC,MAAM,eAAe,CAAA;AAExE,OAAO,EAA2B,MAAM,EAAE,MAAM,YAAY,CAAA;AAE5D,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,cAAc,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEvD,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAG/C,eAAO,MAAM,yBAAyB,QAAwD,CAAA;AAE9F,eAAO,MAAM,uBAAuB,eACtB,cAAc,QACpB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,aACN,MAAM,+DAMd,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAOb,CAAA;AAED,eAAO,MAAM,2BAA2B,eAC1B,cAAc,YAChB,gBAAgB,WAClB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAIvD,OAAO,CAAC,GAAG,CAab,CAAA;AAsCD,eAAO,MAAM,mCAAmC,eAClC,cAAc,UAClB,aAAa,CAAC,GAAG,CAAC,YAChB,MAAM,GAAG,SAAS,aACjB,MAAM,YACP,QAAQ,+DAMf,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CA4Cb,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,cAAc,YAChB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,+DAMT,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAwBb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,eACxB,cAAc,UAClB,aAAa,CAAC,MAAM,CAAC,YACnB,QAAQ,oBACyB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACnE,OAAO,CAAC,MAAM,CAchB,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACH,MAAM,KACd,MAOF,CAAA"}

package/dist/ipld/chunker.js

@@ -35,13 +35,17 @@ import { chunkBuffer, encodeNode } from './utils.js';
 export const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
 const ESTIMATED_LINK_SIZE_IN_BYTES = 64;
 export const DEFAULT_MAX_LINK_PER_NODE = DEFAULT_MAX_CHUNK_SIZE / ESTIMATED_LINK_SIZE_IN_BYTES;
-export const processFileToIPLDFormat = (blockstore, file, totalSize, filename, { maxChunkSize, maxLinkPerNode } = {
+export const processFileToIPLDFormat = (blockstore, file, totalSize, filename, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
     maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
 }) => {
     return processBufferToIPLDFormat(blockstore, file, filename, totalSize, fileBuilders, {
         maxChunkSize,
         maxLinkPerNode,
+        encryption,
+        compression,
     });
 };
 export const processMetadataToIPLDFormat = (blockstore_1, metadata_1, ...args_1) => __awaiter(void 0, [blockstore_1, metadata_1, ...args_1], void 0, function* (blockstore, metadata, limits = {
@@ -56,12 +60,14 @@ export const processMetadataToIPLDFormat = (blockstore_1, metadata_1, ...args_1)
         });
     })(), name, buffer.byteLength, metadataBuilders, limits);
 });
-const processBufferToIPLDFormat = (blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, buffer, filename, totalSize, builders, { maxChunkSize, maxLinkPerNode } = {
+const processBufferToIPLDFormat = (blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, buffer, filename, totalSize, builders, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
     maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
 }) {
     var _a, e_1, _b, _c;
-    const bufferChunks = chunkBuffer(buffer, { maxChunkSize });
+    const bufferChunks = chunkBuffer(buffer, { maxChunkSize: maxChunkSize });
     let CIDs = [];
     try {
         for (var _d = true, bufferChunks_1 = __asyncValues(bufferChunks), bufferChunks_1_1; bufferChunks_1_1 = yield bufferChunks_1.next(), _a = bufferChunks_1_1.done, !_a; _d = true) {
@@ -84,11 +90,15 @@ const processBufferToIPLDFormat = (blockstore_1, buffer_1, filename_1, totalSize
     return processBufferToIPLDFormatFromChunks(blockstore, CIDs, filename, totalSize, builders, {
         maxLinkPerNode,
         maxChunkSize,
+        encryption,
+        compression,
     });
 });
-export const processBufferToIPLDFormatFromChunks = (blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, chunks, filename, totalSize, builders, { maxLinkPerNode, maxChunkSize } = {
-    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+export const processBufferToIPLDFormatFromChunks = (blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, chunks, filename, totalSize, builders, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
 }) {
     var _a, chunks_2, chunks_2_1;
     var _b, e_2, _c, _d;
@@ -114,7 +124,10 @@ export const processBufferToIPLDFormatFromChunks = (blockstore_1, chunks_1, file
         const nodeBytes = yield blockstore.get(CIDs[0]);
         yield blockstore.delete(CIDs[0]);
         const data = decodeIPLDNodeData(nodeBytes);
-        const singleNode = builders.single(Buffer.from(data.data), filename);
+        const singleNode = builders.single(Buffer.from(data.data), filename, {
+            compression,
+            encryption,
+        });
         yield blockstore.put(cidOfNode(singleNode), encodeNode(singleNode));
         const headCID = cidOfNode(singleNode);
         return headCID;
@@ -132,12 +145,20 @@ export const processBufferToIPLDFormatFromChunks = (blockstore_1, chunks_1, file
         depth++;
         CIDs = newCIDs;
     }
-    const head = builders.root(CIDs, totalSize, depth, filename, maxChunkSize);
+    const head = builders.root(CIDs, totalSize, depth, filename, maxChunkSize, {
+        compression,
+        encryption,
+    });
     const headCID = cidOfNode(head);
     yield blockstore.put(headCID, encodeNode(head));
     return headCID;
 });
-export const processFolderToIPLDFormat = (blockstore_1, children_1, name_1, size_1, ...args_1) => __awaiter(void 0, [blockstore_1, children_1, name_1, size_1, ...args_1], void 0, function* (blockstore, children, name, size, { maxLinkPerNode } = { maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE }) {
+export const processFolderToIPLDFormat = (blockstore_1, children_1, name_1, size_1, ...args_1) => __awaiter(void 0, [blockstore_1, children_1, name_1, size_1, ...args_1], void 0, function* (blockstore, children, name, size, { maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, compression = undefined, encryption = undefined, } = {
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    compression: undefined,
+    encryption: undefined,
+}) {
     let cids = children;
     let depth = 0;
     while (cids.length > maxLinkPerNode) {
@@ -152,7 +173,10 @@ export const processFolderToIPLDFormat = (blockstore_1, children_1, name_1, size
         cids = newCIDs;
         depth++;
     }
-    const node = createFolderIpldNode(cids, name, depth, size);
+    const node = createFolderIpldNode(cids, name, depth, size, maxChunkSize, {
+        compression,
+        encryption,
+    });
     const cid = cidOfNode(node);
     yield blockstore.put(cid, encodeNode(node));
     return cid;

package/dist/ipld/nodes.d.ts

@@ -1,15 +1,15 @@
 import { CID } from 'multiformats/cid';
 import { PBNode } from '../ipld/index.js';
-import { OffchainMetadata } from '../metadata/index.js';
+import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js';
 export declare const createFileChunkIpldNode: (data: Buffer) => PBNode;
-export declare const createChunkedFileIpldNode: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number) => PBNode;
+export declare const createChunkedFileIpldNode: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number, uploadOptions?: FileUploadOptions) => PBNode;
 export declare const createFileInlinkIpldNode: (links: CID[], size: number, linkDepth: number, maxNodeSize?: number) => PBNode;
-export declare const createSingleFileIpldNode: (data: Buffer, name?: string) => PBNode;
+export declare const createSingleFileIpldNode: (data: Buffer, name?: string, uploadOptions?: FileUploadOptions) => PBNode;
 export declare const createMetadataInlinkIpldNode: (links: CID[], size: number, linkDepth: number, maxNodeSize?: number) => PBNode;
 export declare const createSingleMetadataIpldNode: (data: Buffer, name?: string) => PBNode;
 export declare const createMetadataChunkIpldNode: (data: Buffer) => PBNode;
 export declare const createChunkedMetadataIpldNode: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number) => PBNode;
-export declare const createFolderIpldNode: (links: CID[], name: string, linkDepth: number, size: number, maxNodeSize?: number) => PBNode;
+export declare const createFolderIpldNode: (links: CID[], name: string, linkDepth: number, size: number, maxNodeSize?: number, uploadOptions?: FileUploadOptions) => PBNode;
 export declare const createFolderInlinkIpldNode: (links: CID[], linkDepth: number, maxNodeSize?: number) => PBNode;
 export declare const createMetadataNode: (metadata: OffchainMetadata, maxNodeSize?: number) => PBNode;
 //# sourceMappingURL=nodes.d.ts.map

package/dist/ipld/nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/ipld/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAc,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKvD,eAAO,MAAM,uBAAuB,SAAU,MAAM,KAAG,MASpD,CAAA;AAKH,eAAO,MAAM,yBAAyB,UAC7B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,KAClB,MAYA,CAAA;AAGH,eAAO,MAAM,wBAAwB,UAC5B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,wBAAwB,SAAU,MAAM,SAAS,MAAM,KAAG,MAUpE,CAAA;AAKH,eAAO,MAAM,4BAA4B,UAChC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,4BAA4B,SAAU,MAAM,SAAS,MAAM,KAAG,MAUxE,CAAA;AAEH,eAAO,MAAM,2BAA2B,SAAU,MAAM,KAAG,MAQxD,CAAA;AAEH,eAAO,MAAM,6BAA6B,UACjC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,KAClB,MAYA,CAAA;AAKH,eAAO,MAAM,oBAAoB,UACxB,GAAG,EAAE,QACN,MAAM,aACD,MAAM,QACX,MAAM,gBACC,MAAM,KAClB,MAYA,CAAA;AAEH,eAAO,MAAM,0BAA0B,UAC9B,GAAG,EAAE,aACD,MAAM,gBACJ,MAAM,KAClB,MAUA,CAAA;AAGH,eAAO,MAAM,kBAAkB,aACnB,gBAAgB,gBACb,MAAM,KAClB,MAcF,CAAA"}
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/ipld/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAc,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAK1E,eAAO,MAAM,uBAAuB,SAAU,MAAM,KAAG,MASpD,CAAA;AAKH,eAAO,MAAM,yBAAyB,UAC7B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,kBACH,iBAAiB,KAChC,MAaA,CAAA;AAGH,eAAO,MAAM,wBAAwB,UAC5B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,wBAAwB,SAC7B,MAAM,SACL,MAAM,kBACG,iBAAiB,KAChC,MAWA,CAAA;AAKH,eAAO,MAAM,4BAA4B,UAChC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,4BAA4B,SAAU,MAAM,SAAS,MAAM,KAAG,MAUxE,CAAA;AAEH,eAAO,MAAM,2BAA2B,SAAU,MAAM,KAAG,MAQxD,CAAA;AAEH,eAAO,MAAM,6BAA6B,UACjC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,KAClB,MAYA,CAAA;AAKH,eAAO,MAAM,oBAAoB,UACxB,GAAG,EAAE,QACN,MAAM,aACD,MAAM,QACX,MAAM,gBACC,MAAM,kBACH,iBAAiB,KAChC,MAaA,CAAA;AAEH,eAAO,MAAM,0BAA0B,UAC9B,GAAG,EAAE,aACD,MAAM,gBACJ,MAAM,KAClB,MAUA,CAAA;AAGH,eAAO,MAAM,kBAAkB,aACnB,gBAAgB,gBACb,MAAM,KAClB,MAcF,CAAA"}

package/dist/ipld/nodes.js

@@ -11,11 +11,12 @@ export const createFileChunkIpldNode = (data) => createNode(encodeIPLDNodeData({
 // Creates a file ipld node
 // links: the CIDs of the file's contents
 // @todo: add the file's metadata
-export const createChunkedFileIpldNode = (links, size, linkDepth, name, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+export const createChunkedFileIpldNode = (links, size, linkDepth, name, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE, uploadOptions) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
     type: MetadataType.File,
     name,
     size,
     linkDepth,
+    uploadOptions,
 }), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
 // Creates a file ipld node
 // links: the CIDs of the file's contents
@@ -27,12 +28,13 @@ export const createFileInlinkIpldNode = (links, size, linkDepth, maxNodeSize = D
 // Creates a file ipld node
 // links: the CIDs of the file's contents
 // @todo: add the file's metadata
-export const createSingleFileIpldNode = (data, name) => createNode(encodeIPLDNodeData({
+export const createSingleFileIpldNode = (data, name, uploadOptions) => createNode(encodeIPLDNodeData({
     type: MetadataType.File,
     name,
     size: data.length,
     linkDepth: 0,
     data,
+    uploadOptions,
 }), []);
 // Creates a file ipld node
 // links: the CIDs of the file's contents
@@ -67,11 +69,12 @@ export const createChunkedMetadataIpldNode = (links, size, linkDepth, name, maxN
 // Creates a folder ipld node
 // links: the CIDs of the folder's contents
 // @todo: add the folder's metadata
-export const createFolderIpldNode = (links, name, linkDepth, size, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+export const createFolderIpldNode = (links, name, linkDepth, size, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE, uploadOptions) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
     type: MetadataType.Folder,
     name,
     size,
     linkDepth,
+    uploadOptions,
 }), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
 export const createFolderInlinkIpldNode = (links, linkDepth, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
     type: MetadataType.FolderInlink,

package/dist/metadata/offchain/file.d.ts

@@ -1,4 +1,5 @@
 import { CID } from 'multiformats';
+import { FileUploadOptions } from '../../index.js';
 export type OffchainFileMetadata = {
     type: 'file';
     dataCid: string;
@@ -7,10 +8,11 @@ export type OffchainFileMetadata = {
     totalSize: number;
     totalChunks: number;
     chunks: ChunkInfo[];
+    uploadOptions?: FileUploadOptions;
 };
 export interface ChunkInfo {
     size: number;
     cid: string;
 }
-export declare const fileMetadata: (headCID: CID, chunks: ChunkInfo[], totalSize: number, name?: string | null, mimeType?: string | null) => OffchainFileMetadata;
+export declare const fileMetadata: (headCID: CID, chunks: ChunkInfo[], totalSize: number, name?: string | null, mimeType?: string | null, uploadOptions?: FileUploadOptions) => OffchainFileMetadata;
 //# sourceMappingURL=file.d.ts.map

package/dist/metadata/offchain/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAGlC,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,eAAO,MAAM,YAAY,YACd,GAAG,UACJ,SAAS,EAAE,aACR,MAAM,SACV,MAAM,GAAG,IAAI,aACT,MAAM,GAAG,IAAI,KACvB,oBAUF,CAAA"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAClC,OAAO,EAAe,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,aAAa,CAAC,EAAE,iBAAiB,CAAA;CAClC,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,eAAO,MAAM,YAAY,YACd,GAAG,UACJ,SAAS,EAAE,aACR,MAAM,SACV,MAAM,GAAG,IAAI,aACT,MAAM,GAAG,IAAI,kBACT,iBAAiB,KAI/B,oBAWF,CAAA"}

package/dist/metadata/offchain/file.js

@@ -1,5 +1,8 @@
 import { cidToString } from '../../index.js';
-export const fileMetadata = (headCID, chunks, totalSize, name, mimeType) => {
+export const fileMetadata = (headCID, chunks, totalSize, name, mimeType, uploadOptions = {
+    compression: undefined,
+    encryption: undefined,
+}) => {
     return {
         type: 'file',
         dataCid: cidToString(headCID),
@@ -8,5 +11,6 @@ export const fileMetadata = (headCID, chunks, totalSize, name, mimeType) => {
         totalSize,
         totalChunks: chunks.length,
         chunks,
+        uploadOptions,
     };
 };

package/dist/metadata/offchain/folder.d.ts

@@ -1,5 +1,6 @@
 import { CID } from 'multiformats';
 import { PBNode } from '../../ipld/index.js';
+import { FileUploadOptions } from '../onchain/index.js';
 interface ChildrenMetadata {
     type: 'folder' | 'file';
     name?: string;
@@ -13,8 +14,9 @@ export type OffchainFolderMetadata = {
     totalSize: number;
     totalFiles: number;
     children: ChildrenMetadata[];
+    uploadOptions: FileUploadOptions;
 };
 export declare const childrenMetadataFromNode: (node: PBNode) => ChildrenMetadata;
-export declare const folderMetadata: (cid: CID | string, children: ChildrenMetadata[], name?: string | null) => OffchainFolderMetadata;
+export declare const folderMetadata: (cid: CID | string, children: ChildrenMetadata[], name?: string | null, uploadOptions?: FileUploadOptions) => OffchainFolderMetadata;
 export {};
 //# sourceMappingURL=folder.d.ts.map

package/dist/metadata/offchain/folder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAG5C,UAAU,gBAAgB;IACxB,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,wBAAwB,SAAU,MAAM,KAAG,gBAYvD,CAAA;AAED,eAAO,MAAM,cAAc,QACpB,GAAG,GAAG,MAAM,YACP,gBAAgB,EAAE,SACrB,MAAM,GAAG,IAAI,KACnB,sBAWF,CAAA"}
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,iBAAiB,EAA8B,MAAM,qBAAqB,CAAA;AAEnF,UAAU,gBAAgB;IACxB,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,wBAAwB,SAAU,MAAM,KAAG,gBAYvD,CAAA;AAED,eAAO,MAAM,cAAc,QACpB,GAAG,GAAG,MAAM,YACP,gBAAgB,EAAE,SACrB,MAAM,GAAG,IAAI,kBACL,iBAAiB,KAC/B,sBAYF,CAAA"}

package/dist/metadata/offchain/folder.js

@@ -13,7 +13,7 @@ export const childrenMetadataFromNode = (node) => {
         name: ipldData.name,
     };
 };
-export const folderMetadata = (cid, children, name) => {
+export const folderMetadata = (cid, children, name, uploadOptions = {}) => {
     cid = typeof cid === 'string' ? cid : cidToString(cid);
     return {
         dataCid: cid,
@@ -22,5 +22,6 @@ export const folderMetadata = (cid, children, name) => {
         children,
         type: 'folder',
         name: name !== null && name !== void 0 ? name : undefined,
+        uploadOptions,
     };
 };

package/dist/metadata/onchain/protobuf/OnchainMetadata.d.ts

@@ -6,6 +6,7 @@ export interface IPLDNodeData {
     size?: number;
     name?: string;
     data?: Uint8Array;
+    uploadOptions?: FileUploadOptions;
 }
 export declare namespace IPLDNodeData {
     const codec: () => Codec<IPLDNodeData>;
@@ -25,4 +26,44 @@ export declare enum MetadataType {
 export declare namespace MetadataType {
     const codec: () => Codec<MetadataType>;
 }
+export interface FileUploadOptions {
+    compression?: CompressionOptions;
+    encryption?: EncryptionOptions;
+}
+export declare namespace FileUploadOptions {
+    const codec: () => Codec<FileUploadOptions>;
+    const encode: (obj: Partial<FileUploadOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<FileUploadOptions>) => FileUploadOptions;
+}
+export interface CompressionOptions {
+    algorithm: CompressionAlgorithm;
+    level?: number;
+    chunkSize?: number;
+}
+export declare namespace CompressionOptions {
+    const codec: () => Codec<CompressionOptions>;
+    const encode: (obj: Partial<CompressionOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<CompressionOptions>) => CompressionOptions;
+}
+export interface EncryptionOptions {
+    algorithm: EncryptionAlgorithm;
+    chunkSize?: number;
+}
+export declare namespace EncryptionOptions {
+    const codec: () => Codec<EncryptionOptions>;
+    const encode: (obj: Partial<EncryptionOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<EncryptionOptions>) => EncryptionOptions;
+}
+export declare enum CompressionAlgorithm {
+    ZLIB = "ZLIB"
+}
+export declare namespace CompressionAlgorithm {
+    const codec: () => Codec<CompressionAlgorithm>;
+}
+export declare enum EncryptionAlgorithm {
+    AES_256_GCM = "AES_256_GCM"
+}
+export declare namespace EncryptionAlgorithm {
+    const codec: () => Codec<EncryptionAlgorithm>;
+}
 //# sourceMappingURL=OnchainMetadata.d.ts.map

package/dist/metadata/onchain/protobuf/OnchainMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OnchainMetadata.d.ts","sourceRoot":"","sources":["../../../../src/metadata/onchain/protobuf/OnchainMetadata.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,KAAK,EAAiB,KAAK,aAAa,EAAuC,MAAM,iBAAiB,CAAA;AACpH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,yBAAiB,YAAY,CAAC;IAGrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CA+E1C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,YAAY,CAAC,KAAG,UAEnD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,YAAY,CAAC,KAAG,YAE7F,CAAA;CACF;AAED,oBAAY,YAAY;IACtB,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;CAChC;AAaD,yBAAiB,YAAY,CAAC;IACrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CAE1C,CAAA;CACF"}
+{"version":3,"file":"OnchainMetadata.d.ts","sourceRoot":"","sources":["../../../../src/metadata/onchain/protobuf/OnchainMetadata.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,KAAK,EAAiB,KAAK,aAAa,EAAuC,MAAM,iBAAiB,CAAA;AACpH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,aAAa,CAAC,EAAE,iBAAiB,CAAA;CAClC;AAED,yBAAiB,YAAY,CAAC;IAGrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CA0F1C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,YAAY,CAAC,KAAG,UAEnD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,YAAY,CAAC,KAAG,YAE7F,CAAA;CACF;AAED,oBAAY,YAAY;IACtB,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;CAChC;AAaD,yBAAiB,YAAY,CAAC;IACrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CAE1C,CAAA;CACF;AACD,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B;AAED,yBAAiB,iBAAiB,CAAC;IAG1B,MAAM,KAAK,QAAO,KAAK,CAAC,iBAAiB,CAqD/C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,iBAAiB,CAAC,KAAG,UAExD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,iBAAiB,CAAC,KAAG,iBAElG,CAAA;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,oBAAoB,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,yBAAiB,kBAAkB,CAAC;IAG3B,MAAM,KAAK,QAAO,KAAK,CAAC,kBAAkB,CA4DhD,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,kBAAkB,CAAC,KAAG,UAEzD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,kBAAkB,CAAC,KAAG,kBAEnG,CAAA;CACF;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,mBAAmB,CAAA;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,yBAAiB,iBAAiB,CAAC;IAG1B,MAAM,KAAK,QAAO,KAAK,CAAC,iBAAiB,CAmD/C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,iBAAiB,CAAC,KAAG,UAExD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,iBAAiB,CAAC,KAAG,iBAElG,CAAA;CACF;AAED,oBAAY,oBAAoB;IAC9B,IAAI,SAAS;CACd;AAMD,yBAAiB,oBAAoB,CAAC;IAC7B,MAAM,KAAK,QAAO,KAAK,CAAC,oBAAoB,CAElD,CAAA;CACF;AACD,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;CAC5B;AAMD,yBAAiB,mBAAmB,CAAC;IAC5B,MAAM,KAAK,QAAO,KAAK,CAAC,mBAAmB,CAEjD,CAAA;CACF"}

package/dist/metadata/onchain/protobuf/OnchainMetadata.js

@@ -33,10 +33,15 @@ export var IPLDNodeData;
                     w.uint32(42);
                     w.bytes(obj.data);
                 }
+                if (obj.uploadOptions != null) {
+                    w.uint32(50);
+                    FileUploadOptions.codec().encode(obj.uploadOptions, w);
+                }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
+                var _a;
                 const obj = {
                     type: MetadataType.File,
                     linkDepth: 0
@@ -65,6 +70,12 @@ export var IPLDNodeData;
                             obj.data = reader.bytes();
                             break;
                         }
+                        case 6: {
+                            obj.uploadOptions = FileUploadOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_a = opts.limits) === null || _a === void 0 ? void 0 : _a.uploadOptions
+                            });
+                            break;
+                        }
                         default: {
                             reader.skipType(tag & 7);
                             break;
@@ -110,3 +121,202 @@ var __MetadataTypeValues;
         return enumeration(__MetadataTypeValues);
     };
 })(MetadataType || (MetadataType = {}));
+export var FileUploadOptions;
+(function (FileUploadOptions) {
+    let _codec;
+    FileUploadOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.compression != null) {
+                    w.uint32(10);
+                    CompressionOptions.codec().encode(obj.compression, w);
+                }
+                if (obj.encryption != null) {
+                    w.uint32(18);
+                    EncryptionOptions.codec().encode(obj.encryption, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                var _a, _b;
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.compression = CompressionOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_a = opts.limits) === null || _a === void 0 ? void 0 : _a.compression
+                            });
+                            break;
+                        }
+                        case 2: {
+                            obj.encryption = EncryptionOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_b = opts.limits) === null || _b === void 0 ? void 0 : _b.encryption
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FileUploadOptions.encode = (obj) => {
+        return encodeMessage(obj, FileUploadOptions.codec());
+    };
+    FileUploadOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, FileUploadOptions.codec(), opts);
+    };
+})(FileUploadOptions || (FileUploadOptions = {}));
+export var CompressionOptions;
+(function (CompressionOptions) {
+    let _codec;
+    CompressionOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.algorithm != null && __CompressionAlgorithmValues[obj.algorithm] !== 0) {
+                    w.uint32(8);
+                    CompressionAlgorithm.codec().encode(obj.algorithm, w);
+                }
+                if (obj.level != null) {
+                    w.uint32(16);
+                    w.int32(obj.level);
+                }
+                if (obj.chunkSize != null) {
+                    w.uint32(24);
+                    w.int32(obj.chunkSize);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    algorithm: CompressionAlgorithm.ZLIB
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.algorithm = CompressionAlgorithm.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.level = reader.int32();
+                            break;
+                        }
+                        case 3: {
+                            obj.chunkSize = reader.int32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    CompressionOptions.encode = (obj) => {
+        return encodeMessage(obj, CompressionOptions.codec());
+    };
+    CompressionOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, CompressionOptions.codec(), opts);
+    };
+})(CompressionOptions || (CompressionOptions = {}));
+export var EncryptionOptions;
+(function (EncryptionOptions) {
+    let _codec;
+    EncryptionOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.algorithm != null && __EncryptionAlgorithmValues[obj.algorithm] !== 0) {
+                    w.uint32(8);
+                    EncryptionAlgorithm.codec().encode(obj.algorithm, w);
+                }
+                if (obj.chunkSize != null) {
+                    w.uint32(16);
+                    w.int32(obj.chunkSize);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    algorithm: EncryptionAlgorithm.AES_256_GCM
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.algorithm = EncryptionAlgorithm.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.chunkSize = reader.int32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    EncryptionOptions.encode = (obj) => {
+        return encodeMessage(obj, EncryptionOptions.codec());
+    };
+    EncryptionOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, EncryptionOptions.codec(), opts);
+    };
+})(EncryptionOptions || (EncryptionOptions = {}));
+export var CompressionAlgorithm;
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm["ZLIB"] = "ZLIB";
+})(CompressionAlgorithm || (CompressionAlgorithm = {}));
+var __CompressionAlgorithmValues;
+(function (__CompressionAlgorithmValues) {
+    __CompressionAlgorithmValues[__CompressionAlgorithmValues["ZLIB"] = 0] = "ZLIB";
+})(__CompressionAlgorithmValues || (__CompressionAlgorithmValues = {}));
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm.codec = () => {
+        return enumeration(__CompressionAlgorithmValues);
+    };
+})(CompressionAlgorithm || (CompressionAlgorithm = {}));
+export var EncryptionAlgorithm;
+(function (EncryptionAlgorithm) {
+    EncryptionAlgorithm["AES_256_GCM"] = "AES_256_GCM";
+})(EncryptionAlgorithm || (EncryptionAlgorithm = {}));
+var __EncryptionAlgorithmValues;
+(function (__EncryptionAlgorithmValues) {
+    __EncryptionAlgorithmValues[__EncryptionAlgorithmValues["AES_256_GCM"] = 0] = "AES_256_GCM";
+})(__EncryptionAlgorithmValues || (__EncryptionAlgorithmValues = {}));
+(function (EncryptionAlgorithm) {
+    EncryptionAlgorithm.codec = () => {
+        return enumeration(__EncryptionAlgorithmValues);
+    };
+})(EncryptionAlgorithm || (EncryptionAlgorithm = {}));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@autonomys/auto-drive",
   "packageManager": "yarn@4.1.1",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {
@@ -41,5 +41,5 @@
     "protons": "^7.6.0",
     "protons-runtime": "^5.5.0"
   },
-  "gitHead": "2c7b1be8b6c2f8fbbfc5bcc6aa6cb9b1f363ce83"
+  "gitHead": "67a6e877c7516104bc82807e91f5fc193372b671"
 }

package/src/ipld/builders.ts

@@ -1,5 +1,6 @@
 import { CID } from 'multiformats/cid'
 import { PBNode } from '../ipld/index.js'
+import { FileUploadOptions } from '../metadata/index.js'
 import {
   createChunkedFileIpldNode,
   createChunkedMetadataIpldNode,
@@ -20,8 +21,9 @@ export interface Builders {
     linkDepth: number,
     name?: string,
     maxNodeSize?: number,
+    fileUploadOptions?: FileUploadOptions,
   ) => PBNode
-  single: (data: Buffer, filename?: string) => PBNode
+  single: (data: Buffer, filename?: string, fileUploadOptions?: FileUploadOptions) => PBNode
 }
 export const metadataBuilders: Builders = {
   inlink: createMetadataInlinkIpldNode,

package/src/ipld/chunker.ts

@@ -2,11 +2,18 @@ import type { BaseBlockstore } from 'blockstore-core'
 import type { AwaitIterable } from 'interface-store'
 import { CID } from 'multiformats'
 import { cidOfNode } from '../cid/index.js'
-import { decodeIPLDNodeData, OffchainMetadata } from '../metadata/index.js'
+import { decodeIPLDNodeData, FileUploadOptions, OffchainMetadata } from '../metadata/index.js'
 import { Builders, fileBuilders, metadataBuilders } from './builders.js'
 import { createFolderInlinkIpldNode, createFolderIpldNode } from './nodes.js'
 import { chunkBuffer, encodeNode, PBNode } from './utils.js'
 
+type ChunkerLimits = {
+  maxChunkSize: number
+  maxLinkPerNode: number
+}
+
+type ChunkerOptions = ChunkerLimits & FileUploadOptions
+
 export const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024
 
 const ESTIMATED_LINK_SIZE_IN_BYTES = 64
@@ -17,14 +24,23 @@ export const processFileToIPLDFormat = (
   file: AwaitIterable<Buffer>,
   totalSize: number,
   filename?: string,
-  { maxChunkSize, maxLinkPerNode }: { maxChunkSize: number; maxLinkPerNode: number } = {
+  {
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE,
+    encryption = undefined,
+    compression = undefined,
+  }: Partial<ChunkerOptions> = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
     maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
   },
 ): Promise<CID> => {
   return processBufferToIPLDFormat(blockstore, file, filename, totalSize, fileBuilders, {
     maxChunkSize,
     maxLinkPerNode,
+    encryption,
+    compression,
   })
 }
 
@@ -56,12 +72,19 @@ const processBufferToIPLDFormat = async (
   filename: string | undefined,
   totalSize: number,
   builders: Builders,
-  { maxChunkSize, maxLinkPerNode }: { maxChunkSize: number; maxLinkPerNode: number } = {
+  {
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE,
+    encryption = undefined,
+    compression = undefined,
+  }: ChunkerOptions = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
     maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
   },
 ): Promise<CID> => {
-  const bufferChunks = chunkBuffer(buffer, { maxChunkSize })
+  const bufferChunks = chunkBuffer(buffer, { maxChunkSize: maxChunkSize })
 
   let CIDs: CID[] = []
   for await (const chunk of bufferChunks) {
@@ -74,6 +97,8 @@ const processBufferToIPLDFormat = async (
   return processBufferToIPLDFormatFromChunks(blockstore, CIDs, filename, totalSize, builders, {
     maxLinkPerNode,
     maxChunkSize,
+    encryption,
+    compression,
   })
 }
 
@@ -83,9 +108,16 @@ export const processBufferToIPLDFormatFromChunks = async (
   filename: string | undefined,
   totalSize: number,
   builders: Builders,
-  { maxLinkPerNode, maxChunkSize }: { maxLinkPerNode: number; maxChunkSize: number } = {
-    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+  {
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE,
+    encryption = undefined,
+    compression = undefined,
+  }: Partial<ChunkerOptions> = {
     maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
   },
 ): Promise<CID> => {
   let chunkCount = 0
@@ -99,7 +131,10 @@ export const processBufferToIPLDFormatFromChunks = async (
     const nodeBytes = await blockstore.get(CIDs[0])
     await blockstore.delete(CIDs[0])
     const data = decodeIPLDNodeData(nodeBytes)
-    const singleNode = builders.single(Buffer.from(data.data!), filename)
+    const singleNode = builders.single(Buffer.from(data.data!), filename, {
+      compression,
+      encryption,
+    })
     await blockstore.put(cidOfNode(singleNode), encodeNode(singleNode))
     const headCID = cidOfNode(singleNode)
 
@@ -120,7 +155,10 @@ export const processBufferToIPLDFormatFromChunks = async (
     depth++
     CIDs = newCIDs
   }
-  const head = builders.root(CIDs, totalSize, depth, filename, maxChunkSize)
+  const head = builders.root(CIDs, totalSize, depth, filename, maxChunkSize, {
+    compression,
+    encryption,
+  })
   const headCID = cidOfNode(head)
   await blockstore.put(headCID, encodeNode(head))
 
@@ -132,7 +170,17 @@ export const processFolderToIPLDFormat = async (
   children: CID[],
   name: string,
   size: number,
-  { maxLinkPerNode }: { maxLinkPerNode: number } = { maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE },
+  {
+    maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE,
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    compression = undefined,
+    encryption = undefined,
+  }: Partial<ChunkerOptions> = {
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    compression: undefined,
+    encryption: undefined,
+  },
 ): Promise<CID> => {
   let cids = children
   let depth = 0
@@ -149,7 +197,10 @@ export const processFolderToIPLDFormat = async (
     depth++
   }
 
-  const node = createFolderIpldNode(cids, name, depth, size)
+  const node = createFolderIpldNode(cids, name, depth, size, maxChunkSize, {
+    compression,
+    encryption,
+  })
   const cid = cidOfNode(node)
   await blockstore.put(cid, encodeNode(node))
 

package/src/ipld/nodes.ts

@@ -1,6 +1,6 @@
 import { CID } from 'multiformats/cid'
 import { createNode, PBNode } from '../ipld/index.js'
-import { OffchainMetadata } from '../metadata/index.js'
+import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js'
 import { encodeIPLDNodeData, MetadataType } from '../metadata/onchain/index.js'
 import { DEFAULT_MAX_CHUNK_SIZE, ensureNodeMaxSize } from './chunker.js'
 
@@ -25,6 +25,7 @@ export const createChunkedFileIpldNode = (
   linkDepth: number,
   name?: string,
   maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  uploadOptions?: FileUploadOptions,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -33,6 +34,7 @@ export const createChunkedFileIpldNode = (
         name,
         size,
         linkDepth,
+        uploadOptions,
       }),
       links.map((cid) => ({ Hash: cid })),
     ),
@@ -61,7 +63,11 @@ export const createFileInlinkIpldNode = (
 // Creates a file ipld node
 // links: the CIDs of the file's contents
 // @todo: add the file's metadata
-export const createSingleFileIpldNode = (data: Buffer, name?: string): PBNode =>
+export const createSingleFileIpldNode = (
+  data: Buffer,
+  name?: string,
+  uploadOptions?: FileUploadOptions,
+): PBNode =>
   createNode(
     encodeIPLDNodeData({
       type: MetadataType.File,
@@ -69,6 +75,7 @@ export const createSingleFileIpldNode = (data: Buffer, name?: string): PBNode =>
       size: data.length,
       linkDepth: 0,
       data,
+      uploadOptions,
     }),
     [],
   )
@@ -148,6 +155,7 @@ export const createFolderIpldNode = (
   linkDepth: number,
   size: number,
   maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  uploadOptions?: FileUploadOptions,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -156,6 +164,7 @@ export const createFolderIpldNode = (
         name,
         size,
         linkDepth,
+        uploadOptions,
       }),
       links.map((cid) => ({ Hash: cid })),
     ),

package/src/metadata/offchain/file.ts

@@ -1,5 +1,5 @@
 import { CID } from 'multiformats'
-import { cidToString } from '../../index.js'
+import { cidToString, FileUploadOptions } from '../../index.js'
 
 export type OffchainFileMetadata = {
   type: 'file'
@@ -9,6 +9,7 @@ export type OffchainFileMetadata = {
   totalSize: number
   totalChunks: number
   chunks: ChunkInfo[]
+  uploadOptions?: FileUploadOptions
 }
 
 export interface ChunkInfo {
@@ -22,6 +23,10 @@ export const fileMetadata = (
   totalSize: number,
   name?: string | null,
   mimeType?: string | null,
+  uploadOptions: FileUploadOptions = {
+    compression: undefined,
+    encryption: undefined,
+  },
 ): OffchainFileMetadata => {
   return {
     type: 'file',
@@ -31,5 +36,6 @@ export const fileMetadata = (
     totalSize,
     totalChunks: chunks.length,
     chunks,
+    uploadOptions,
   }
 }

package/src/metadata/offchain/folder.ts

@@ -1,7 +1,7 @@
 import { CID } from 'multiformats'
 import { cidOfNode, cidToString } from '../../cid/index.js'
 import { PBNode } from '../../ipld/index.js'
-import { IPLDNodeData, MetadataType } from '../onchain/index.js'
+import { FileUploadOptions, IPLDNodeData, MetadataType } from '../onchain/index.js'
 
 interface ChildrenMetadata {
   type: 'folder' | 'file'
@@ -17,6 +17,7 @@ export type OffchainFolderMetadata = {
   totalSize: number
   totalFiles: number
   children: ChildrenMetadata[]
+  uploadOptions: FileUploadOptions
 }
 
 export const childrenMetadataFromNode = (node: PBNode): ChildrenMetadata => {
@@ -37,6 +38,7 @@ export const folderMetadata = (
   cid: CID | string,
   children: ChildrenMetadata[],
   name?: string | null,
+  uploadOptions: FileUploadOptions = {},
 ): OffchainFolderMetadata => {
   cid = typeof cid === 'string' ? cid : cidToString(cid)
 
@@ -47,5 +49,6 @@ export const folderMetadata = (
     children,
     type: 'folder',
     name: name ?? undefined,
+    uploadOptions,
   }
 }

package/src/metadata/onchain/protobuf/OnchainMetadata.proto

@@ -6,6 +6,7 @@ message IPLDNodeData {
   optional int32 size = 3;
   optional string name = 4;
   optional bytes data = 5;
+  optional FileUploadOptions uploadOptions = 6;
 }
 
 // MetadataType defines the possible types of metadata.
@@ -19,3 +20,27 @@ enum MetadataType {
   MetadataInlink = 6;
   MetadataChunk = 7;
 }
+
+message FileUploadOptions {
+  optional CompressionOptions compression = 1;
+  optional EncryptionOptions encryption = 2;
+}
+
+message CompressionOptions {
+  CompressionAlgorithm algorithm = 1;
+  optional int32 level = 2;
+  optional int32 chunkSize = 3;
+}
+
+message EncryptionOptions {
+  EncryptionAlgorithm algorithm = 1;
+  optional int32 chunkSize = 2;
+}
+
+enum CompressionAlgorithm {
+  ZLIB = 0;
+}
+
+enum EncryptionAlgorithm {
+  AES_256_GCM = 0;
+}

package/src/metadata/onchain/protobuf/OnchainMetadata.ts

@@ -13,6 +13,7 @@ export interface IPLDNodeData {
   size?: number
   name?: string
   data?: Uint8Array
+  uploadOptions?: FileUploadOptions
 }
 
 export namespace IPLDNodeData {
@@ -50,6 +51,11 @@ export namespace IPLDNodeData {
           w.bytes(obj.data)
         }
 
+        if (obj.uploadOptions != null) {
+          w.uint32(50)
+          FileUploadOptions.codec().encode(obj.uploadOptions, w)
+        }
+
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
@@ -85,6 +91,12 @@ export namespace IPLDNodeData {
               obj.data = reader.bytes()
               break
             }
+            case 6: {
+              obj.uploadOptions = FileUploadOptions.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.uploadOptions
+              })
+              break
+            }
             default: {
               reader.skipType(tag & 7)
               break
@@ -135,3 +147,251 @@ export namespace MetadataType {
     return enumeration<MetadataType>(__MetadataTypeValues)
   }
 }
+export interface FileUploadOptions {
+  compression?: CompressionOptions
+  encryption?: EncryptionOptions
+}
+
+export namespace FileUploadOptions {
+  let _codec: Codec<FileUploadOptions>
+
+  export const codec = (): Codec<FileUploadOptions> => {
+    if (_codec == null) {
+      _codec = message<FileUploadOptions>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.compression != null) {
+          w.uint32(10)
+          CompressionOptions.codec().encode(obj.compression, w)
+        }
+
+        if (obj.encryption != null) {
+          w.uint32(18)
+          EncryptionOptions.codec().encode(obj.encryption, w)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length, opts = {}) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              obj.compression = CompressionOptions.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.compression
+              })
+              break
+            }
+            case 2: {
+              obj.encryption = EncryptionOptions.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.encryption
+              })
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<FileUploadOptions>): Uint8Array => {
+    return encodeMessage(obj, FileUploadOptions.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<FileUploadOptions>): FileUploadOptions => {
+    return decodeMessage(buf, FileUploadOptions.codec(), opts)
+  }
+}
+
+export interface CompressionOptions {
+  algorithm: CompressionAlgorithm
+  level?: number
+  chunkSize?: number
+}
+
+export namespace CompressionOptions {
+  let _codec: Codec<CompressionOptions>
+
+  export const codec = (): Codec<CompressionOptions> => {
+    if (_codec == null) {
+      _codec = message<CompressionOptions>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.algorithm != null && __CompressionAlgorithmValues[obj.algorithm] !== 0) {
+          w.uint32(8)
+          CompressionAlgorithm.codec().encode(obj.algorithm, w)
+        }
+
+        if (obj.level != null) {
+          w.uint32(16)
+          w.int32(obj.level)
+        }
+
+        if (obj.chunkSize != null) {
+          w.uint32(24)
+          w.int32(obj.chunkSize)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length, opts = {}) => {
+        const obj: any = {
+          algorithm: CompressionAlgorithm.ZLIB
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              obj.algorithm = CompressionAlgorithm.codec().decode(reader)
+              break
+            }
+            case 2: {
+              obj.level = reader.int32()
+              break
+            }
+            case 3: {
+              obj.chunkSize = reader.int32()
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<CompressionOptions>): Uint8Array => {
+    return encodeMessage(obj, CompressionOptions.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<CompressionOptions>): CompressionOptions => {
+    return decodeMessage(buf, CompressionOptions.codec(), opts)
+  }
+}
+
+export interface EncryptionOptions {
+  algorithm: EncryptionAlgorithm
+  chunkSize?: number
+}
+
+export namespace EncryptionOptions {
+  let _codec: Codec<EncryptionOptions>
+
+  export const codec = (): Codec<EncryptionOptions> => {
+    if (_codec == null) {
+      _codec = message<EncryptionOptions>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.algorithm != null && __EncryptionAlgorithmValues[obj.algorithm] !== 0) {
+          w.uint32(8)
+          EncryptionAlgorithm.codec().encode(obj.algorithm, w)
+        }
+
+        if (obj.chunkSize != null) {
+          w.uint32(16)
+          w.int32(obj.chunkSize)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length, opts = {}) => {
+        const obj: any = {
+          algorithm: EncryptionAlgorithm.AES_256_GCM
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              obj.algorithm = EncryptionAlgorithm.codec().decode(reader)
+              break
+            }
+            case 2: {
+              obj.chunkSize = reader.int32()
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<EncryptionOptions>): Uint8Array => {
+    return encodeMessage(obj, EncryptionOptions.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<EncryptionOptions>): EncryptionOptions => {
+    return decodeMessage(buf, EncryptionOptions.codec(), opts)
+  }
+}
+
+export enum CompressionAlgorithm {
+  ZLIB = 'ZLIB'
+}
+
+enum __CompressionAlgorithmValues {
+  ZLIB = 0
+}
+
+export namespace CompressionAlgorithm {
+  export const codec = (): Codec<CompressionAlgorithm> => {
+    return enumeration<CompressionAlgorithm>(__CompressionAlgorithmValues)
+  }
+}
+export enum EncryptionAlgorithm {
+  AES_256_GCM = 'AES_256_GCM'
+}
+
+enum __EncryptionAlgorithmValues {
+  AES_256_GCM = 0
+}
+
+export namespace EncryptionAlgorithm {
+  export const codec = (): Codec<EncryptionAlgorithm> => {
+    return enumeration<EncryptionAlgorithm>(__EncryptionAlgorithmValues)
+  }
+}