@autonomys/auto-drive 0.7.3 → 0.7.4

package/dist/src/ipld/utils.js

@@ -0,0 +1,51 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { decode, encode } from '@ipld/dag-pb';
+export const chunkBuffer = function (buffer, chunkSize) {
+    return __asyncGenerator(this, arguments, function* () {
+        var _a, e_1, _b, _c;
+        let target = Buffer.alloc(0);
+        try {
+            for (var _d = true, buffer_1 = __asyncValues(buffer), buffer_1_1; buffer_1_1 = yield __await(buffer_1.next()), _a = buffer_1_1.done, !_a; _d = true) {
+                _c = buffer_1_1.value;
+                _d = false;
+                let chunk = _c;
+                target = Buffer.concat([target, chunk]);
+                while (target.length >= chunkSize) {
+                    yield yield __await(target.subarray(0, chunkSize));
+                    target = target.subarray(chunkSize);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = buffer_1.return)) yield __await(_b.call(buffer_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (target.length > 0) {
+            yield yield __await(target);
+        }
+    });
+};
+export const encodeNode = (node) => Buffer.from(encode(node));
+export const decodeNode = (data) => decode(data);

package/dist/src/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './offchain/index.js';
+export * from './onchain/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/metadata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metadata/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA"}

package/dist/src/metadata/index.js

@@ -0,0 +1,2 @@
+export * from './offchain/index.js';
+export * from './onchain/index.js';

package/dist/src/metadata/offchain/base.d.ts

@@ -0,0 +1,4 @@
+import { OffchainFileMetadata } from './file.js';
+import { OffchainFolderMetadata } from './folder.js';
+export type OffchainMetadata = OffchainFolderMetadata | OffchainFileMetadata;
+//# sourceMappingURL=base.d.ts.map

package/dist/src/metadata/offchain/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/metadata/offchain/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAEpD,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GAAG,oBAAoB,CAAA"}

package/dist/src/metadata/offchain/base.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import { IPLDDag } from '../../index.js';
+export type OffchainFileMetadata = {
+    type: 'file';
+    dataCid: string;
+    name?: string;
+    mimeType?: string;
+    totalSize: number;
+    totalChunks: number;
+    chunks: ChunkInfo[];
+};
+export interface ChunkInfo {
+    size: number;
+    cid: string;
+}
+export declare const fileMetadata: (dag: IPLDDag, totalSize: number, name?: string, mimeType?: string) => OffchainFileMetadata;
+//# sourceMappingURL=file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/metadata/offchain/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,OAAO,EAA8B,MAAM,gBAAgB,CAAA;AAE5F,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,QAClB,OAAO,aACD,MAAM,SACV,MAAM,aACF,MAAM,KAChB,oBAiBF,CAAA"}

package/dist/src/metadata/offchain/file.js

@@ -0,0 +1,19 @@
+import { cidOfNode, cidToString, IPLDNodeData } from '../../index.js';
+export const fileMetadata = (dag, totalSize, name, mimeType) => {
+    const chunks = Array.from(dag.nodes.values()).filter((n) => n.Data && IPLDNodeData.decode(n.Data).data);
+    return {
+        type: 'file',
+        dataCid: cidToString(dag.headCID),
+        name,
+        mimeType,
+        totalSize,
+        totalChunks: chunks.length,
+        chunks: chunks.map((chunk) => {
+            var _a, _b;
+            return ({
+                cid: cidToString(cidOfNode(chunk)),
+                size: (_b = (_a = chunk.Data) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+            });
+        }),
+    };
+};

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

@@ -0,0 +1,17 @@
+interface ChildrenMetadata {
+    type: 'folder' | 'file';
+    name?: string;
+    cid: string;
+    totalSize: number;
+}
+export type OffchainFolderMetadata = {
+    type: 'folder';
+    dataCid: string;
+    name?: string;
+    totalSize: number;
+    totalFiles: number;
+    children: ChildrenMetadata[];
+};
+export declare const folderMetadata: (cid: string, children: ChildrenMetadata[], name?: string) => OffchainFolderMetadata;
+export {};
+//# sourceMappingURL=folder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../../../src/metadata/offchain/folder.ts"],"names":[],"mappings":"AAAA,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,cAAc,QACpB,MAAM,YACD,gBAAgB,EAAE,SACrB,MAAM,KACZ,sBASF,CAAA"}

package/dist/src/metadata/offchain/folder.js

@@ -0,0 +1,10 @@
+export const folderMetadata = (cid, children, name) => {
+    return {
+        dataCid: cid,
+        totalSize: children.reduce((acc, child) => acc + child.totalSize, 0),
+        totalFiles: children.length,
+        children,
+        type: 'folder',
+        name,
+    };
+};

package/dist/src/metadata/offchain/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base.js';
+export * from './file.js';
+export * from './folder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/metadata/offchain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/metadata/offchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA"}

package/dist/src/metadata/offchain/index.js

@@ -0,0 +1,3 @@
+export * from './base.js';
+export * from './file.js';
+export * from './folder.js';

package/dist/src/metadata/onchain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './protobuf/OnchainMetadata.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/metadata/onchain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/metadata/onchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,YAAY,CAAA"}

package/dist/src/metadata/onchain/index.js

@@ -0,0 +1,2 @@
+export * from './protobuf/OnchainMetadata.js';
+export * from './utils.js';

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

@@ -0,0 +1,28 @@
+import { type Codec, type DecodeOptions } from 'protons-runtime';
+import type { Uint8ArrayList } from 'uint8arraylist';
+export interface IPLDNodeData {
+    type: MetadataType;
+    linkDepth: number;
+    size?: number;
+    name?: string;
+    data?: Uint8Array;
+}
+export declare namespace IPLDNodeData {
+    const codec: () => Codec<IPLDNodeData>;
+    const encode: (obj: Partial<IPLDNodeData>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<IPLDNodeData>) => IPLDNodeData;
+}
+export declare enum MetadataType {
+    File = "File",
+    FileInlink = "FileInlink",
+    FileChunk = "FileChunk",
+    Folder = "Folder",
+    FolderInlink = "FolderInlink",
+    Metadata = "Metadata",
+    MetadataInlink = "MetadataInlink",
+    MetadataChunk = "MetadataChunk"
+}
+export declare namespace MetadataType {
+    const codec: () => Codec<MetadataType>;
+}
+//# sourceMappingURL=OnchainMetadata.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,112 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime';
+export var IPLDNodeData;
+(function (IPLDNodeData) {
+    let _codec;
+    IPLDNodeData.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.type != null && __MetadataTypeValues[obj.type] !== 0) {
+                    w.uint32(8);
+                    MetadataType.codec().encode(obj.type, w);
+                }
+                if ((obj.linkDepth != null && obj.linkDepth !== 0)) {
+                    w.uint32(16);
+                    w.int32(obj.linkDepth);
+                }
+                if (obj.size != null) {
+                    w.uint32(24);
+                    w.int32(obj.size);
+                }
+                if (obj.name != null) {
+                    w.uint32(34);
+                    w.string(obj.name);
+                }
+                if (obj.data != null) {
+                    w.uint32(42);
+                    w.bytes(obj.data);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    type: MetadataType.File,
+                    linkDepth: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.type = MetadataType.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.linkDepth = reader.int32();
+                            break;
+                        }
+                        case 3: {
+                            obj.size = reader.int32();
+                            break;
+                        }
+                        case 4: {
+                            obj.name = reader.string();
+                            break;
+                        }
+                        case 5: {
+                            obj.data = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    IPLDNodeData.encode = (obj) => {
+        return encodeMessage(obj, IPLDNodeData.codec());
+    };
+    IPLDNodeData.decode = (buf, opts) => {
+        return decodeMessage(buf, IPLDNodeData.codec(), opts);
+    };
+})(IPLDNodeData || (IPLDNodeData = {}));
+export var MetadataType;
+(function (MetadataType) {
+    MetadataType["File"] = "File";
+    MetadataType["FileInlink"] = "FileInlink";
+    MetadataType["FileChunk"] = "FileChunk";
+    MetadataType["Folder"] = "Folder";
+    MetadataType["FolderInlink"] = "FolderInlink";
+    MetadataType["Metadata"] = "Metadata";
+    MetadataType["MetadataInlink"] = "MetadataInlink";
+    MetadataType["MetadataChunk"] = "MetadataChunk";
+})(MetadataType || (MetadataType = {}));
+var __MetadataTypeValues;
+(function (__MetadataTypeValues) {
+    __MetadataTypeValues[__MetadataTypeValues["File"] = 0] = "File";
+    __MetadataTypeValues[__MetadataTypeValues["FileInlink"] = 1] = "FileInlink";
+    __MetadataTypeValues[__MetadataTypeValues["FileChunk"] = 2] = "FileChunk";
+    __MetadataTypeValues[__MetadataTypeValues["Folder"] = 3] = "Folder";
+    __MetadataTypeValues[__MetadataTypeValues["FolderInlink"] = 4] = "FolderInlink";
+    __MetadataTypeValues[__MetadataTypeValues["Metadata"] = 5] = "Metadata";
+    __MetadataTypeValues[__MetadataTypeValues["MetadataInlink"] = 6] = "MetadataInlink";
+    __MetadataTypeValues[__MetadataTypeValues["MetadataChunk"] = 7] = "MetadataChunk";
+})(__MetadataTypeValues || (__MetadataTypeValues = {}));
+(function (MetadataType) {
+    MetadataType.codec = () => {
+        return enumeration(__MetadataTypeValues);
+    };
+})(MetadataType || (MetadataType = {}));

package/dist/src/metadata/onchain/utils.d.ts

@@ -0,0 +1,4 @@
+import { IPLDNodeData } from '../onchain/index.js';
+export declare const encodeIPLDNodeData: (metadata: IPLDNodeData) => Uint8Array;
+export declare const decodeIPLDNodeData: (data: Uint8Array) => IPLDNodeData;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/metadata/onchain/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/metadata/onchain/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAElD,eAAO,MAAM,kBAAkB,aAAc,YAAY,KAAG,UAE3D,CAAA;AAED,eAAO,MAAM,kBAAkB,SAAU,UAAU,KAAG,YAOrD,CAAA"}

package/dist/src/metadata/onchain/utils.js

@@ -0,0 +1,12 @@
+import { decode } from '@ipld/dag-pb';
+import { IPLDNodeData } from '../onchain/index.js';
+export const encodeIPLDNodeData = (metadata) => {
+    return IPLDNodeData.encode(metadata);
+};
+export const decodeIPLDNodeData = (data) => {
+    const decoded = decode(data);
+    if (!decoded.Data) {
+        throw new Error('Invalid data');
+    }
+    return IPLDNodeData.decode(decoded.Data);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@autonomys/auto-drive",
   "packageManager": "yarn@4.1.1",
-  "version": "0.7.3",
+  "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": "dde96ad7b5d7f2bf023da23cbd1de89b0e22f1c6"
+  "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,
   }
 }