@autonomys/auto-dag-data 1.0.8 → 1.0.9

package/dist/compression/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAE/C,eAAO,MAAM,sBAAsB,QAAc,CAAA;AAEjD,wBAAuB,YAAY,CACjC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,EACE,KAAS,EACT,SAAkC,EAClC,SAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB;AAED,wBAAuB,cAAc,CACnC,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,EACrC,EACE,SAAkC,EAClC,SAAqC,EACrC,KAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAE/C,eAAO,MAAM,sBAAsB,QAAc,CAAA;AAEjD,wBAAuB,YAAY,CACjC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,EACE,KAAS,EACT,SAAkC,EAClC,SAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB;AAED,wBAAuB,cAAc,CACnC,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,EACrC,EACE,SAAkC,EAClC,SAAS,EACT,KAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB"}

package/dist/compression/index.js

@@ -64,7 +64,7 @@ export function compressFile(file_1, _a) {
     });
 }
 export function decompressFile(compressedFile_1, _a) {
-    return __asyncGenerator(this, arguments, function* decompressFile_1(compressedFile, { chunkSize = COMPRESSION_CHUNK_SIZE, algorithm = CompressionAlgorithm.ZLIB, level = 9, }) {
+    return __asyncGenerator(this, arguments, function* decompressFile_1(compressedFile, { chunkSize = COMPRESSION_CHUNK_SIZE, algorithm, level = 9, }) {
         var _b, e_2, _c, _d;
         if (algorithm !== CompressionAlgorithm.ZLIB) {
             throw new Error('Unsupported compression algorithm');

package/dist/encryption/index.d.ts

@@ -1,8 +1,9 @@
+import { AwaitIterable } from 'interface-store';
 import { EncryptionOptions } from '../metadata/index.js';
 import type { PickPartial } from '../utils/types.js';
 import { PasswordGenerationOptions } from './types.js';
 export declare const ENCRYPTING_CHUNK_SIZE: number;
 export declare const getKeyFromPassword: ({ password, salt }: PasswordGenerationOptions) => Promise<CryptoKey>;
-export declare const encryptFile: (file: AsyncIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
-export declare const decryptFile: (file: AsyncIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
+export declare const encryptFile: (file: AwaitIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
+export declare const decryptFile: (file: AwaitIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
 //# sourceMappingURL=index.d.ts.map

package/dist/encryption/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/encryption/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAItD,eAAO,MAAM,qBAAqB,QAAc,CAAA;AAMhD,eAAO,MAAM,kBAAkB,uBAA8B,yBAAyB,uBAyBrF,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACkC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC5F,aAAa,CAAC,MAAM,CAetB,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACiC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC3F,aAAa,CAAC,MAAM,CA+BtB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/encryption/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAuB,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAItD,eAAO,MAAM,qBAAqB,QAAc,CAAA;AAMhD,eAAO,MAAM,kBAAkB,uBAA8B,yBAAyB,uBAyBrF,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACkC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC5F,aAAa,CAAC,MAAM,CAetB,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACiC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC3F,aAAa,CAAC,MAAM,CA+BtB,CAAA"}

package/dist/ipld/chunker.d.ts

@@ -10,6 +10,7 @@ type ChunkerLimits = {
 };
 type ChunkerOptions = ChunkerLimits & FileUploadOptions;
 export declare const DEFAULT_NODE_MAX_SIZE = 65535;
+export declare const MAX_NAME_SIZE = 255;
 export declare const NODE_METADATA_SIZE: number;
 export declare const DEFAULT_MAX_CHUNK_SIZE: number;
 export declare const LINK_SIZE_IN_BYTES = 40;

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,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE9F,OAAO,EAAE,QAAQ,EAAkC,MAAM,eAAe,CAAA;AAExE,OAAO,EAA2B,MAAM,EAAE,MAAM,YAAY,CAAA;AAE5D,KAAK,aAAa,GAAG;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,cAAc,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEvD,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAiB1C,eAAO,MAAM,kBAAkB,QAML,CAAA;AAE1B,eAAO,MAAM,sBAAsB,QAA6C,CAAA;AAEhF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AACpC,eAAO,MAAM,yBAAyB,QAA0D,CAAA;AAEhG,eAAO,MAAM,uBAAuB,eACtB,cAAc,QACpB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,aACN,MAAM,8DAMd,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAWb,CAAA;AAED,eAAO,MAAM,2BAA2B,eAC1B,cAAc,YAChB,gBAAgB,WAClB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAItD,OAAO,CAAC,GAAG,CAiBb,CAAA;AA0CD,eAAO,MAAM,mCAAmC,eAClC,cAAc,UAClB,aAAa,CAAC,GAAG,CAAC,YAChB,MAAM,GAAG,SAAS,aACjB,MAAM,YACP,QAAQ,2EAMf,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAgDb,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,cAAc,YAChB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,2EAMT,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CA4Bb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,eACxB,cAAc,UAClB,aAAa,CAAC,MAAM,CAAC,YACnB,QAAQ,qBACyB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KAGnE,OAAO,CAAC,MAAM,CAiBhB,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;AAE9F,OAAO,EAAE,QAAQ,EAAkC,MAAM,eAAe,CAAA;AAExE,OAAO,EAA2B,MAAM,EAAE,MAAM,YAAY,CAAA;AAE5D,KAAK,aAAa,GAAG;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,cAAc,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEvD,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAS1C,eAAO,MAAM,aAAa,MAAM,CAAA;AAQhC,eAAO,MAAM,kBAAkB,QAML,CAAA;AAE1B,eAAO,MAAM,sBAAsB,QAA6C,CAAA;AAEhF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AACpC,eAAO,MAAM,yBAAyB,QAA0D,CAAA;AAEhG,eAAO,MAAM,uBAAuB,eACtB,cAAc,QACpB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,aACN,MAAM,8DAMd,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAWb,CAAA;AAED,eAAO,MAAM,2BAA2B,eAC1B,cAAc,YAChB,gBAAgB,WAClB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAItD,OAAO,CAAC,GAAG,CAiBb,CAAA;AA0CD,eAAO,MAAM,mCAAmC,eAClC,cAAc,UAClB,aAAa,CAAC,GAAG,CAAC,YAChB,MAAM,GAAG,SAAS,aACjB,MAAM,YACP,QAAQ,2EAMf,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAgDb,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,cAAc,YAChB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,2EAMT,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CA4Bb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,eACxB,cAAc,UAClB,aAAa,CAAC,MAAM,CAAC,YACnB,QAAQ,qBACyB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KAGnE,OAAO,CAAC,MAAM,CAiBhB,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACH,MAAM,KACd,MAOF,CAAA"}

package/dist/ipld/chunker.js

@@ -41,7 +41,7 @@ const NODE_LINK_DEPTH_SIZE = 4;
 // u64 -> 8 bytes
 const NODE_SIZE_SIZE = 8;
 // Limit at 255 string length (Mac Limit)
-const MAX_NAME_SIZE = 255;
+export const MAX_NAME_SIZE = 255;
 const END_OF_STRING_BYTE = 1;
 const NODE_NAME_SIZE = MAX_NAME_SIZE + END_OF_STRING_BYTE;
 // Upload options may be amplified in the future

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,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI1E,OAAO,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAG/C,eAAO,MAAM,uBAAuB,SAC5B,MAAM,gBACC,MAAM,KAClB,MAYA,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,gBACpB,MAAM,KAClB,MAcA,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,SAChC,MAAM,gBACC,MAAM,KAClB,MAWA,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"}
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/ipld/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI1E,OAAO,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAG/C,eAAO,MAAM,uBAAuB,SAC5B,MAAM,gBACC,MAAM,KAClB,MAYA,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,gBACpB,MAAM,KAClB,MAcA,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,SAChC,MAAM,gBACC,MAAM,KAClB,MAWA,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,MAeF,CAAA"}

package/dist/ipld/nodes.js

@@ -89,5 +89,6 @@ export const createMetadataNode = (metadata, maxNodeSize = DEFAULT_NODE_MAX_SIZE
         name: metadata.name,
         linkDepth: 0,
         data,
+        size: BigInt(data.length).valueOf(),
     })), maxNodeSize);
 };

package/jest.config.ts

@@ -14,4 +14,5 @@ module.exports = {
       },
     ],
   },
+  coveragePathIgnorePatterns: ['./src/metadata/onchain/protobuf'],
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@autonomys/auto-dag-data",
   "packageManager": "yarn@4.1.1",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {
@@ -48,5 +48,5 @@
     "protons": "^7.6.0",
     "protons-runtime": "^5.5.0"
   },
-  "gitHead": "88b1b90467db7dd1e301387451ed727189f9808c"
+  "gitHead": "c8da43fe9c2ba885d1ff5e0241d9a41e2c4f3389"
 }

package/src/compression/index.ts

@@ -49,7 +49,7 @@ export async function* decompressFile(
   compressedFile: AwaitIterable<Buffer>,
   {
     chunkSize = COMPRESSION_CHUNK_SIZE,
-    algorithm = CompressionAlgorithm.ZLIB,
+    algorithm,
     level = 9,
   }: PickPartial<CompressionOptions, 'algorithm'>,
 ): AsyncIterable<Buffer> {

package/src/encryption/index.ts

@@ -1,5 +1,6 @@
 import { Crypto } from '@peculiar/webcrypto'
 import { randomBytes } from 'crypto'
+import { AwaitIterable } from 'interface-store'
 import { EncryptionAlgorithm, EncryptionOptions } from '../metadata/index.js'
 import { asyncByChunk } from '../utils/async.js'
 import type { PickPartial } from '../utils/types.js'
@@ -41,7 +42,7 @@ export const getKeyFromPassword = async ({ password, salt }: PasswordGenerationO
 }
 
 export const encryptFile = async function* (
-  file: AsyncIterable<Buffer>,
+  file: AwaitIterable<Buffer>,
   password: string,
   { chunkSize = ENCRYPTING_CHUNK_SIZE, algorithm }: PickPartial<EncryptionOptions, 'algorithm'>,
 ): AsyncIterable<Buffer> {
@@ -62,7 +63,7 @@ export const encryptFile = async function* (
 }
 
 export const decryptFile = async function* (
-  file: AsyncIterable<Buffer>,
+  file: AwaitIterable<Buffer>,
   password: string,
   { chunkSize = ENCRYPTED_CHUNK_SIZE, algorithm }: PickPartial<EncryptionOptions, 'algorithm'>,
 ): AsyncIterable<Buffer> {

package/src/ipld/chunker.ts

@@ -24,7 +24,7 @@ const NODE_LINK_DEPTH_SIZE = 4
 // u64 -> 8 bytes
 const NODE_SIZE_SIZE = 8
 // Limit at 255 string length (Mac Limit)
-const MAX_NAME_SIZE = 255
+export const MAX_NAME_SIZE = 255
 const END_OF_STRING_BYTE = 1
 const NODE_NAME_SIZE = MAX_NAME_SIZE + END_OF_STRING_BYTE
 // Upload options may be amplified in the future

package/src/ipld/nodes.ts

@@ -218,6 +218,7 @@ export const createMetadataNode = (
         name: metadata.name,
         linkDepth: 0,
         data,
+        size: BigInt(data.length).valueOf(),
       }),
     ),
     maxNodeSize,

package/tests/chunker.spec.ts

@@ -1,14 +1,24 @@
 import { BaseBlockstore, MemoryBlockstore } from 'blockstore-core'
-import { cidOfNode, cidToString, createSingleFileIpldNode } from '../src'
 import {
+  cidOfNode,
+  cidToString,
+  createFileChunkIpldNode,
+  createSingleFileIpldNode,
+  fileBuilders,
+} from '../src'
+import {
+  DEFAULT_MAX_CHUNK_SIZE,
   LINK_SIZE_IN_BYTES,
+  MAX_NAME_SIZE,
   NODE_METADATA_SIZE,
+  processBufferToIPLDFormatFromChunks,
+  processChunksToIPLDFormat,
   processFileToIPLDFormat,
   processFolderToIPLDFormat,
   processMetadataToIPLDFormat,
 } from '../src/ipld/chunker'
-import { createNode, decodeNode, PBNode } from '../src/ipld/utils'
-import { decodeIPLDNodeData, IPLDNodeData, MetadataType, OffchainMetadata } from '../src/metadata'
+import { createNode, decodeNode, encodeNode, PBNode } from '../src/ipld/utils'
+import { fileMetadata, IPLDNodeData, MetadataType, OffchainMetadata } from '../src/metadata'
 
 describe('chunker', () => {
   describe('file creation', () => {
@@ -88,6 +98,22 @@ describe('chunker', () => {
       })
     })
 
+    it('create a file with long name should throw an error', async () => {
+      const name = 'a'.repeat(MAX_NAME_SIZE + 1)
+      const blockstore = new MemoryBlockstore()
+      expect(() =>
+        processFileToIPLDFormat(blockstore, [Buffer.from('hello')], BigInt(5), name),
+      ).toThrow(`Filename is too long: ${name.length} > ${MAX_NAME_SIZE}`)
+    })
+
+    it('create a file with long name from buffer should throw an error', async () => {
+      const name = 'a'.repeat(MAX_NAME_SIZE + 1)
+      const blockstore = new MemoryBlockstore()
+      await expect(
+        processBufferToIPLDFormatFromChunks(blockstore, [], name, BigInt(5), fileBuilders),
+      ).rejects.toThrow(`Filename is too long: ${name.length} > ${MAX_NAME_SIZE}`)
+    })
+
     it('create a file dag with inlinks', async () => {
       const chunkLength = 1000
       const maxNodeSize = chunkLength + NODE_METADATA_SIZE
@@ -194,6 +220,89 @@ describe('chunker', () => {
       expect(rootCount).toBe(1)
       expect(inlinkCount).toBe(3)
     })
+
+    it('create a folder with long name should throw an error', async () => {
+      const name = 'a'.repeat(MAX_NAME_SIZE + 1)
+      const blockstore = new MemoryBlockstore()
+      await expect(processFolderToIPLDFormat(blockstore, [], name, BigInt(1000))).rejects.toThrow(
+        `Filename is too long: ${name.length} > ${MAX_NAME_SIZE}`,
+      )
+    })
+  })
+
+  describe('asyncronous file creation', () => {
+    it('process chunks to IPLD format should return the leftover buffer', async () => {
+      const filename = 'test.txt'
+      const chunkSize = DEFAULT_MAX_CHUNK_SIZE
+      const chunksCount = 1.5
+      const buffer = Buffer.from(
+        Array.from({ length: chunkSize * chunksCount })
+          .map(() => Math.floor(Math.random() * 16).toString(16))
+          .join(''),
+      )
+
+      const leftoverSize = buffer.length % chunkSize
+      const blockstore = new MemoryBlockstore()
+      const leftover = await processChunksToIPLDFormat(blockstore, [buffer], fileBuilders)
+      expect(leftover.length).toBe(leftoverSize)
+    })
+
+    it('process chunks with exact chunk size len(leftover)=0', async () => {
+      const filename = 'test.txt'
+      const chunkSize = DEFAULT_MAX_CHUNK_SIZE
+      const chunksCount = 4
+      const buffer = Buffer.from(
+        Array.from({ length: chunkSize * chunksCount })
+          .map(() => Math.floor(Math.random() * 16).toString(16))
+          .join(''),
+      )
+
+      const blockstore = new MemoryBlockstore()
+      const leftover = await processChunksToIPLDFormat(blockstore, [buffer], fileBuilders)
+
+      expect(leftover.length).toBe(0)
+    })
+
+    it('process file by chunks', async () => {
+      const filename = 'test.txt'
+      const chunkSize = DEFAULT_MAX_CHUNK_SIZE
+      const chunksCount = 4.5
+      const buffer = Buffer.from(
+        Array.from({ length: chunkSize * chunksCount })
+          .map(() => Math.floor(Math.random() * 16).toString(16))
+          .join(''),
+      )
+
+      const blockstore = new MemoryBlockstore()
+      const leftover = await processChunksToIPLDFormat(blockstore, [buffer], fileBuilders)
+      const leftoverCid = createFileChunkIpldNode(leftover)
+      await blockstore.put(cidOfNode(leftoverCid), encodeNode(leftoverCid))
+
+      const mapCIDs = (async function* () {
+        for await (const { cid } of blockstore.getAll()) {
+          yield cid
+        }
+      })()
+
+      const headCID = await processBufferToIPLDFormatFromChunks(
+        blockstore,
+        mapCIDs,
+        filename,
+        BigInt(buffer.length),
+        fileBuilders,
+      )
+
+      const headNode = decodeNode(await blockstore.get(headCID))
+      expect(headNode?.Links.length).toBe(Math.ceil(chunksCount))
+      expect(cidToString(headNode?.Links[headNode.Links.length - 1].Hash)).toEqual(
+        cidToString(cidOfNode(leftoverCid)),
+      )
+      const ipldMetadata = IPLDNodeData.decode(headNode?.Data ?? new Uint8Array())
+      expect(ipldMetadata.name).toBe(filename)
+      expect(ipldMetadata.type).toBe(MetadataType.File)
+      expect(ipldMetadata.linkDepth).toBe(1)
+      expect(ipldMetadata.size!.toString()).toBe(buffer.length.toString())
+    })
   })
 
   describe('metadata creation', () => {
@@ -209,11 +318,31 @@ describe('chunker', () => {
       }
 
       const blockstore = new MemoryBlockstore()
-      const headCID = await processMetadataToIPLDFormat(blockstore, metadata)
+      await processMetadataToIPLDFormat(blockstore, metadata)
       const nodes = await nodesFromBlockstore(blockstore)
       expect(nodes.length).toBe(1)
     })
 
+    it('create a metadata dag with long name should throw an error', async () => {
+      const name = 'a'.repeat(MAX_NAME_SIZE + 1)
+      const metadata = fileMetadata(
+        cidOfNode(createNode(Buffer.from(Math.random().toString()))),
+        [
+          {
+            cid: cidToString(cidOfNode(createNode(Buffer.from(Math.random().toString())))),
+            size: BigInt(1000),
+          },
+        ],
+        BigInt(1000),
+        name,
+      )
+
+      const blockstore = new MemoryBlockstore()
+      await expect(processMetadataToIPLDFormat(blockstore, metadata)).rejects.toThrow(
+        `Filename is too long: ${name.length} > ${MAX_NAME_SIZE}`,
+      )
+    })
+
     it('large metadata dag represented into multiple nodes', async () => {
       const metadata: OffchainMetadata = {
         type: 'file',

package/tests/compression.spec.ts

@@ -1,5 +1,10 @@
+import { AwaitIterable } from 'interface-store'
 import { compressFile, COMPRESSION_CHUNK_SIZE, CompressionAlgorithm, decompressFile } from '../src'
 
+const awaitIterable = async (it: AwaitIterable<Buffer>) => {
+  for await (const _ of it);
+}
+
 describe('compression', () => {
   it('compresses and decompresses a file with default options', async () => {
     const file = Buffer.from('hello'.repeat(1000))
@@ -55,4 +60,80 @@ describe('compression', () => {
 
     expect(decompressedBuffer.toString()).toBe(file.toString())
   })
+
+  it('asynchronously iterates over the compressed file for chunked compression', async () => {
+    const chunkSize = COMPRESSION_CHUNK_SIZE
+    const chunks = 5
+    const chunk = Buffer.from('hello'.repeat(chunkSize))
+    const compressed = compressFile(
+      (async function* () {
+        for (let i = 0; i < chunks; i++) {
+          yield chunk
+          await new Promise((resolve) => setTimeout(resolve, 50))
+        }
+      })(),
+      {
+        level: 9,
+        algorithm: CompressionAlgorithm.ZLIB,
+      },
+    )
+
+    await awaitIterable(compressed)
+  }, 10_000)
+
+  it('throws an error if the compression algorithm is not supported', async () => {
+    await expect(
+      awaitIterable(compressFile([Buffer.from('hello')], { algorithm: 'efwhhgfew' as any })),
+    ).rejects.toThrow('Unsupported compression algorithm')
+  })
+
+  it('throws an error if the compression level is invalid', async () => {
+    await expect(
+      awaitIterable(
+        compressFile([Buffer.from('hello')], {
+          algorithm: CompressionAlgorithm.ZLIB,
+          level: -1 as any,
+        }),
+      ),
+    ).rejects.toThrow('Invalid compression level')
+  })
+
+  it('throws an error if the chunk size is invalid', async () => {
+    await expect(
+      awaitIterable(
+        compressFile([Buffer.from('hello')], {
+          algorithm: CompressionAlgorithm.ZLIB,
+          chunkSize: 0,
+        }),
+      ),
+    ).rejects.toThrow('Invalid chunk size')
+  })
+
+  it('throws an error if the decompression algorithm is not supported', async () => {
+    await expect(
+      awaitIterable(decompressFile([Buffer.from('hello')], { algorithm: 'efwhhgfew' as any })),
+    ).rejects.toThrow('Unsupported compression algorithm')
+  })
+
+  it('throws an error if the decompression chunk size is invalid', async () => {
+    await expect(
+      awaitIterable(
+        decompressFile([Buffer.from('hello')], {
+          chunkSize: 0,
+          algorithm: CompressionAlgorithm.ZLIB,
+        }),
+      ),
+    ).rejects.toThrow('Invalid chunk size')
+  })
+
+  it('throws an error if the compression level is invalid', async () => {
+    await expect(
+      awaitIterable(
+        decompressFile([Buffer.from('hello')], {
+          level: -1 as any,
+          algorithm: CompressionAlgorithm.ZLIB,
+        }),
+      ),
+    ).rejects.toThrow('Invalid compression level')
+  })
 })

package/tests/encryption.spec.ts

@@ -1,5 +1,10 @@
+import { AwaitIterable } from 'interface-store'
 import { decryptFile, encryptFile, EncryptionAlgorithm } from '../src'
 
+const awaitIterable = async (it: AwaitIterable<Buffer>) => {
+  for await (const _ of it);
+}
+
 describe('encryption', () => {
   it('encrypts and decrypts a file with default chunk size', async () => {
     const chunk = 'hello'
@@ -101,4 +106,20 @@ describe('encryption', () => {
       decryptedBuffer = Buffer.concat([decryptedBuffer, chunk])
     }
   })
+
+  it('throws an error if the encryption algorithm is not supported', async () => {
+    await expect(
+      awaitIterable(
+        encryptFile([Buffer.from('hello')], 'password', { algorithm: 'efwhhgfew' as any }),
+      ),
+    ).rejects.toThrow('Unsupported encryption algorithm')
+  })
+
+  it('throws an error if the decryption algorithm is not supported', async () => {
+    await expect(
+      awaitIterable(
+        decryptFile([Buffer.from('hello')], 'password', { algorithm: 'efwhhgfew' as any }),
+      ),
+    ).rejects.toThrow('Unsupported encryption algorithm')
+  })
 })

package/tests/fileRetrievability.spec.ts

@@ -0,0 +1,181 @@
+import { MemoryBlockstore } from 'blockstore-core'
+import {
+  createChunkedFileIpldNode,
+  createSingleFileIpldNode,
+  decodeIPLDNodeData,
+  decodeNode,
+  DEFAULT_MAX_CHUNK_SIZE,
+  encodeNode,
+  fileBuilders,
+  processBufferToIPLDFormatFromChunks,
+  processChunksToIPLDFormat,
+  processFileToIPLDFormat,
+} from '../src'
+
+describe('file retrievability', () => {
+  it('should be able to retrieve a file', () => {
+    const filename = 'test.txt'
+    const buffer = Buffer.from('hello world')
+    const encodedNode = encodeNode(createSingleFileIpldNode(buffer, filename))
+
+    const decodedNode = decodeIPLDNodeData(encodedNode)
+
+    expect(decodedNode.name).toBe(filename)
+    expect(decodedNode.size!.toString()).toBe(buffer.length.toString())
+    expect(Buffer.from(decodedNode.data ?? '').toString()).toBe(buffer.toString())
+  })
+
+  it('should be able to retrieve a file with chunked file', async () => {
+    const filename = 'test.txt'
+    const expectedChunks = 4
+    const fileSize = expectedChunks * DEFAULT_MAX_CHUNK_SIZE
+    const buffer = Buffer.from(
+      Array.from({ length: fileSize })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join(''),
+    )
+    const blockstore = new MemoryBlockstore()
+    const headCID = await processFileToIPLDFormat(
+      blockstore,
+      [buffer],
+      BigInt(buffer.length),
+      filename,
+    )
+
+    const node = await blockstore.get(headCID)
+    const decodedNode = decodeNode(node)
+
+    expect(decodedNode.Links.length).toBe(expectedChunks)
+    const chunks = await Promise.all(
+      decodedNode.Links.map(async (e) => {
+        const chunk = await blockstore.get(e.Hash)
+        const decodedChunk = decodeIPLDNodeData(chunk)
+        expect(decodedChunk.data).toBeDefined()
+        return Buffer.from(decodedChunk.data!)
+      }),
+    )
+
+    const allChunks = await Promise.all(chunks)
+    const finalBuffer = Buffer.concat(allChunks)
+    expect(finalBuffer.toString()).toBe(buffer.toString())
+  })
+
+  it('should be able to retrieve a file with chunked file with uneven chunk size', async () => {
+    const filename = 'test.txt'
+    const expectedChunks = 1.5
+    const fileSize = Math.floor(expectedChunks * DEFAULT_MAX_CHUNK_SIZE)
+    const buffer = Buffer.from(
+      Array.from({ length: fileSize })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join(''),
+    )
+
+    const blockstore = new MemoryBlockstore()
+    const headCID = await processFileToIPLDFormat(
+      blockstore,
+      [buffer],
+      BigInt(buffer.length),
+      filename,
+    )
+
+    const node = await blockstore.get(headCID)
+    const decodedNode = decodeNode(node)
+
+    expect(decodedNode.Links.length).toBe(Math.ceil(expectedChunks))
+    const chunks = await Promise.all(
+      decodedNode.Links.map(async (e) => {
+        const chunk = await blockstore.get(e.Hash)
+        const decodedChunk = decodeIPLDNodeData(chunk)
+        expect(decodedChunk.data).toBeDefined()
+        return Buffer.from(decodedChunk.data!)
+      }),
+    )
+
+    const allChunks = await Promise.all(chunks)
+    const finalBuffer = Buffer.concat(allChunks)
+    expect(finalBuffer.toString()).toBe(buffer.toString())
+  })
+
+  it('should be able to retrieve a file with chunked file with different chunk size and uneven chunk size ', async () => {
+    const filename = 'test.txt'
+
+    const expectedChunks = 2
+    const chunkSize = Math.floor((DEFAULT_MAX_CHUNK_SIZE * 100) / 121)
+    const fileSize = Math.floor(expectedChunks * chunkSize)
+    const buffer = Buffer.from(
+      Array.from({ length: fileSize })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join(''),
+    )
+
+    const blockstore = new MemoryBlockstore()
+    const headCID = await processFileToIPLDFormat(
+      blockstore,
+      [buffer],
+      BigInt(buffer.length),
+      filename,
+    )
+
+    const node = await blockstore.get(headCID)
+    const decodedNode = decodeNode(node)
+
+    expect(decodedNode.Links.length).toBe(Math.ceil(expectedChunks))
+    const chunks = await Promise.all(
+      decodedNode.Links.map(async (e) => {
+        const chunk = await blockstore.get(e.Hash)
+        const decodedChunk = decodeIPLDNodeData(chunk)
+        expect(decodedChunk.data).toBeDefined()
+        return Buffer.from(decodedChunk.data!)
+      }),
+    )
+
+    const allChunks = await Promise.all(chunks)
+    const finalBuffer = Buffer.concat(allChunks)
+    expect(finalBuffer.toString()).toBe(buffer.toString())
+  })
+
+  it('should retrieve a file generated asynchronously', async () => {
+    const filename = 'test.txt'
+    const chunkSize = DEFAULT_MAX_CHUNK_SIZE
+    const chunksCount = 50
+    const buffer = Buffer.from(
+      Array.from({ length: chunkSize * chunksCount })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join(''),
+    )
+
+    const blockstore = new MemoryBlockstore()
+    await processChunksToIPLDFormat(blockstore, [buffer], fileBuilders)
+
+    const mapCIDs = (async function* () {
+      for await (const { cid } of blockstore.getAll()) {
+        yield cid
+      }
+    })()
+
+    const headCID = await processBufferToIPLDFormatFromChunks(
+      blockstore,
+      mapCIDs,
+      filename,
+      BigInt(buffer.length),
+      fileBuilders,
+    )
+
+    const node = await blockstore.get(headCID)
+    const decodedNode = decodeNode(node)
+
+    expect(decodedNode.Links.length).toBe(chunksCount)
+    const chunks = await Promise.all(
+      decodedNode.Links.map(async (e) => {
+        const chunk = await blockstore.get(e.Hash)
+        const decodedChunk = decodeIPLDNodeData(chunk)
+        expect(decodedChunk.data).toBeDefined()
+        return Buffer.from(decodedChunk.data!)
+      }),
+    )
+
+    const allChunks = await Promise.all(chunks)
+    const finalBuffer = Buffer.concat(allChunks)
+    expect(finalBuffer.toString()).toBe(buffer.toString())
+  })
+})

package/tests/nodes.spec.ts

@@ -1,11 +1,14 @@
 import {
   cidOfNode,
+  cidToString,
   createChunkedFileIpldNode,
   createFileChunkIpldNode,
   createSingleFileIpldNode,
+  fileMetadata,
 } from '../src/index.js'
-import { createNode, DEFAULT_MAX_CHUNK_SIZE, DEFAULT_NODE_MAX_SIZE } from '../src/ipld/index.js'
+import { createMetadataNode, createNode, DEFAULT_NODE_MAX_SIZE } from '../src/ipld/index.js'
 import { IPLDNodeData, MetadataType } from '../src/metadata/onchain/protobuf/OnchainMetadata.js'
+import { stringifyMetadata } from '../src/utils/metadata.js'
 
 describe('node creation', () => {
   describe('files nodes', () => {
@@ -77,4 +80,24 @@ describe('node creation', () => {
       expect(decoded.linkDepth).toBe(0)
     })
   })
+
+  describe('metadata nodes', () => {
+    it('metadata node | correctly params setup', () => {
+      const randomCID = cidOfNode(createNode(Buffer.from(Math.random().toString())))
+      const metadata = fileMetadata(
+        randomCID,
+        [{ cid: cidToString(randomCID), size: BigInt(1000) }],
+        BigInt(1000),
+        'test.txt',
+      )
+      const metadataSize = Buffer.from(stringifyMetadata(metadata)).length
+
+      const metadataNode = createMetadataNode(metadata)
+
+      const decoded = IPLDNodeData.decode(metadataNode.Data ?? new Uint8Array())
+      expect(decoded.type).toBe(MetadataType.Metadata)
+      expect(decoded.name).toBe('test.txt')
+      expect(decoded.size!.toString()).toBe(BigInt(metadataSize).toString())
+    })
+  })
 })

package/tests/offchainMetadata.spec.ts

@@ -0,0 +1,149 @@
+import { MemoryBlockstore } from 'blockstore-core'
+import {
+  childrenMetadataFromNode,
+  cidOfNode,
+  cidToString,
+  CompressionAlgorithm,
+  createFolderIpldNode,
+  createNode,
+  createSingleFileIpldNode,
+  EncryptionAlgorithm,
+  fileMetadata,
+  folderMetadata,
+  processFolderToIPLDFormat,
+} from '../src'
+
+export const stringifyWithBigInt = (obj: any) => {
+  return JSON.stringify(obj, (key, value) => (typeof value === 'bigint' ? value.toString() : value))
+}
+
+describe('offchain metadata', () => {
+  describe('file metadata', () => {
+    it('matches expected structure', () => {
+      const buffer = Buffer.from('hello world')
+      const cid = cidOfNode(createSingleFileIpldNode(buffer, 'test.txt'))
+      const chunks = [{ size: BigInt(11).valueOf(), cid: cidToString(cid) }]
+      const metadata = fileMetadata(cid, chunks, BigInt(buffer.length), 'test.txt')
+      expect(metadata.name).toBe('test.txt')
+      expect(metadata.totalSize === BigInt(buffer.length)).toBe(true)
+      expect(metadata.type).toBe('file')
+      expect(metadata.dataCid).toBe(cidToString(cid))
+      expect(stringifyWithBigInt(metadata.chunks)).toEqual(stringifyWithBigInt(chunks))
+      expect(metadata.uploadOptions).toEqual({
+        compression: undefined,
+        encryption: undefined,
+      })
+      expect(metadata.totalChunks).toBe(1)
+      expect(metadata.mimeType).toBeUndefined()
+    })
+
+    it('matches expected structure with mime type', () => {
+      const buffer = Buffer.from('hello world')
+      const cid = cidOfNode(createSingleFileIpldNode(buffer, 'test.txt'))
+      const chunks = [{ size: BigInt(11).valueOf(), cid: cidToString(cid) }]
+      const metadata = fileMetadata(cid, chunks, BigInt(buffer.length), 'test.txt', 'text/plain')
+      expect(metadata.name).toBe('test.txt')
+      expect(metadata.totalSize === BigInt(buffer.length)).toBe(true)
+      expect(metadata.type).toBe('file')
+      expect(metadata.dataCid).toBe(cidToString(cid))
+      expect(stringifyWithBigInt(metadata.chunks)).toEqual(stringifyWithBigInt(chunks))
+      expect(metadata.uploadOptions).toEqual({
+        compression: undefined,
+        encryption: undefined,
+      })
+      expect(metadata.mimeType).toBe('text/plain')
+    })
+  })
+
+  describe('folder metadata', () => {
+    it('matches expected structure', async () => {
+      const CIDs = Array.from({ length: 10 }, () =>
+        cidOfNode(createNode(Buffer.from(Math.random().toString()))),
+      )
+      const name = 'test'
+      const childSize = BigInt(1000)
+      const blockstore = new MemoryBlockstore()
+      const folder = await processFolderToIPLDFormat(blockstore, CIDs, 'test', childSize)
+      const children = CIDs.map((cid) => ({
+        cid: cidToString(cid),
+        totalSize: childSize,
+        type: 'file' as const,
+      }))
+
+      const metadata = folderMetadata(cidToString(folder), children, name)
+
+      const totalSize = childSize * BigInt(CIDs.length)
+      expect(metadata.name).toBe(name)
+      expect(metadata.totalSize.toString()).toBe(totalSize.toString())
+      expect(metadata.type).toBe('folder')
+      expect(metadata.dataCid).toBe(cidToString(folder))
+      expect(stringifyWithBigInt(metadata.children)).toEqual(stringifyWithBigInt(children))
+      expect(metadata.uploadOptions).toEqual({
+        compression: undefined,
+        encryption: undefined,
+      })
+    })
+
+    it('matches expected structure with upload options', async () => {
+      const CIDs = Array.from({ length: 10 }, () =>
+        cidOfNode(createNode(Buffer.from(Math.random().toString()))),
+      )
+      const childSize = BigInt(1000)
+      const name = 'test'
+      const blockstore = new MemoryBlockstore()
+      const folder = await processFolderToIPLDFormat(blockstore, CIDs, name, childSize)
+      const children = CIDs.map((cid) => ({
+        cid: cidToString(cid),
+        totalSize: childSize,
+        type: 'file' as const,
+      }))
+
+      const metadata = folderMetadata(cidToString(folder), children, name, {
+        compression: {
+          algorithm: CompressionAlgorithm.ZLIB,
+          level: 1,
+        },
+        encryption: {
+          algorithm: EncryptionAlgorithm.AES_256_GCM,
+        },
+      })
+
+      const totalSize = childSize * BigInt(CIDs.length)
+      expect(metadata.name).toBe(name)
+      expect(metadata.totalSize.toString()).toBe(totalSize.toString())
+      expect(metadata.type).toBe('folder')
+      expect(metadata.dataCid).toBe(cidToString(folder))
+      expect(stringifyWithBigInt(metadata.children)).toEqual(stringifyWithBigInt(children))
+      expect(metadata.uploadOptions).toEqual({
+        compression: {
+          algorithm: CompressionAlgorithm.ZLIB,
+          level: 1,
+        },
+        encryption: {
+          algorithm: EncryptionAlgorithm.AES_256_GCM,
+        },
+      })
+    })
+
+    it('file children metadata from node', () => {
+      const node = createSingleFileIpldNode(Buffer.from('hello world'), 'test.txt')
+      const metadata = childrenMetadataFromNode(node)
+      expect(metadata.cid).toBe(cidToString(cidOfNode(node)))
+      expect(metadata.totalSize.toString()).toBe('11')
+      expect(metadata.type).toBe('file')
+      expect(metadata.name).toBe('test.txt')
+    })
+
+    it('folder children metadata from node', () => {
+      const name = 'test'
+      const size = BigInt(1000)
+      const cid = cidOfNode(createFolderIpldNode([], name, 0, size))
+      const node = createFolderIpldNode([cid], name, 0, size)
+      const metadata = childrenMetadataFromNode(node)
+      expect(metadata.cid).toBe(cidToString(cidOfNode(node)))
+      expect(metadata.totalSize.toString()).toBe(size.toString())
+      expect(metadata.type).toBe('folder')
+      expect(metadata.name).toBe(name)
+    })
+  })
+})