@autonomys/auto-dag-data 1.0.7 → 1.0.9

package/src/ipld/nodes.ts

@@ -2,13 +2,13 @@ import { CID } from 'multiformats/cid'
 import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js'
 import { encodeIPLDNodeData, MetadataType } from '../metadata/onchain/index.js'
 import { stringifyMetadata } from '../utils/metadata.js'
-import { DEFAULT_MAX_CHUNK_SIZE, ensureNodeMaxSize } from './chunker.js'
+import { DEFAULT_NODE_MAX_SIZE, ensureNodeMaxSize } from './chunker.js'
 import { createNode, PBNode } from './index.js'
 
 /// Creates a file chunk ipld node
 export const createFileChunkIpldNode = (
   data: Buffer,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -31,7 +31,7 @@ export const createChunkedFileIpldNode = (
   size: bigint,
   linkDepth: number,
   name?: string,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
   uploadOptions?: FileUploadOptions,
 ): PBNode =>
   ensureNodeMaxSize(
@@ -53,7 +53,7 @@ export const createFileInlinkIpldNode = (
   links: CID[],
   size: number,
   linkDepth: number,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -74,7 +74,7 @@ export const createSingleFileIpldNode = (
   data: Buffer,
   name?: string,
   uploadOptions?: FileUploadOptions,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -98,7 +98,7 @@ export const createMetadataInlinkIpldNode = (
   links: CID[],
   size: number,
   linkDepth: number,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -129,7 +129,7 @@ export const createSingleMetadataIpldNode = (data: Buffer, name?: string): PBNod
 
 export const createMetadataChunkIpldNode = (
   data: Buffer,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -148,7 +148,7 @@ export const createChunkedMetadataIpldNode = (
   size: bigint,
   linkDepth: number,
   name?: string,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -171,7 +171,7 @@ export const createFolderIpldNode = (
   name: string,
   linkDepth: number,
   size: bigint,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
   uploadOptions?: FileUploadOptions,
 ): PBNode =>
   ensureNodeMaxSize(
@@ -191,7 +191,7 @@ export const createFolderIpldNode = (
 export const createFolderInlinkIpldNode = (
   links: CID[],
   linkDepth: number,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode =>
   ensureNodeMaxSize(
     createNode(
@@ -207,7 +207,7 @@ export const createFolderInlinkIpldNode = (
 /// Creates a metadata ipld node
 export const createMetadataNode = (
   metadata: OffchainMetadata,
-  maxNodeSize: number = DEFAULT_MAX_CHUNK_SIZE,
+  maxNodeSize: number = DEFAULT_NODE_MAX_SIZE,
 ): PBNode => {
   const data = Buffer.from(stringifyMetadata(metadata))
 
@@ -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 } 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', () => {
@@ -30,7 +33,7 @@ describe('node creation', () => {
     })
 
     it('single file root node | buffer too large', () => {
-      const maxNodeSize = DEFAULT_MAX_CHUNK_SIZE
+      const maxNodeSize = DEFAULT_NODE_MAX_SIZE
       const buffer = Buffer.from('h'.repeat(maxNodeSize))
       expect(() => createSingleFileIpldNode(buffer, 'test.txt')).toThrow()
     })
@@ -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())
+    })
+  })
 })