fix: mantaray marshal and unmarshal logic (#1202)

* fix: mantaray marshal and unmarshal logic

* fix: upload spec fails

* fix: lint

---------

Co-authored-by: Gergely Békési <gergely.bekesi@ethswarm.org>

Author: slapec93

src/manifest/manifest.ts

@@ -74,7 +74,10 @@ export class Fork {
       throw Error('Fork#marshal node.selfAddress is not set')
     }
     const data: Uint8Array[] = []
-    data.push(new Uint8Array([this.node.determineType()]))
+    // Re-emit the type byte read from the chunk when the node is untouched, so an
+    // unmarshal → marshal round-trip is byte-identical. determineType() can only
+    // recompute it correctly once the node's children are loaded/built in memory.
+    data.push(new Uint8Array([this.node.type ?? this.node.determineType()]))
     data.push(Binary.numberToUint8(this.prefix.length))
     data.push(this.prefix)
 
@@ -126,7 +129,7 @@ export class Fork {
       metadata = JSON.parse(DECODER.decode(reader.read(metadataLength)))
     }
 
-    return new Fork(prefix, new MantarayNode({ selfAddress, metadata, path: prefix }))
+    return new Fork(prefix, new MantarayNode({ selfAddress, metadata, path: prefix, type }))
   }
 }
 
@@ -137,6 +140,7 @@ interface MantarayNodeOptions {
   metadata?: Record<string, string> | null
   path?: Uint8Array | null
   parent?: MantarayNode | null
+  type?: number | null
 }
 
 export class MantarayNode {
@@ -147,6 +151,7 @@ export class MantarayNode {
   public path: Uint8Array = new Uint8Array(0)
   public forks: Map<number, Fork> = new Map()
   public parent: MantarayNode | null = null
+  public type: number | null = null
 
   constructor(options?: MantarayNodeOptions) {
     if (options?.targetAddress) {
@@ -172,6 +177,8 @@ export class MantarayNode {
     if (options?.parent) {
       this.parent = options.parent
     }
+
+    this.type = options?.type ?? null
   }
 
   get fullPath(): Uint8Array {
@@ -243,14 +250,23 @@ export class MantarayNode {
         fork.node.selfAddress = (await fork.node.calculateSelfAddress()).toUint8Array()
       }
     }
+    const hasEntry = !Binary.equals(this.targetAddress, NULL_ADDRESS)
+    let refBytesSize = 0
+
+    if (hasEntry) {
+      refBytesSize = this.targetAddress.length
+    } else {
+      for (const fork of this.forks.values()) {
+        if (fork.node.selfAddress) {
+          refBytesSize = fork.node.selfAddress.length
+          break
+        }
+      }
+    }
     const header = new Uint8Array(32)
     header.set(VERSION_02_HASH, 0)
-    header.set(
-      Binary.equals(this.targetAddress, NULL_ADDRESS) && Binary.equals(this.path, new Uint8Array([47]))
-        ? Binary.numberToUint8(0)
-        : Binary.numberToUint8(this.targetAddress.length),
-      31,
-    )
+    header.set(Binary.numberToUint8(refBytesSize), 31)
+    const entry = hasEntry ? this.targetAddress : new Uint8Array(refBytesSize)
     const forkBitmap = new Uint8Array(32)
     for (const fork of this.forks.keys()) {
       Binary.setBit(forkBitmap, fork, 1, 'LE')
@@ -261,17 +277,7 @@ export class MantarayNode {
         forks.push(this.forks.get(i)!.marshal())
       }
     }
-    const data = Binary.xorCypher(
-      Binary.concatBytes(
-        header,
-        Binary.equals(this.targetAddress, NULL_ADDRESS) && Binary.equals(this.path, new Uint8Array([47]))
-          ? new Uint8Array(0)
-          : this.targetAddress,
-        forkBitmap,
-        ...forks,
-      ),
-      this.obfuscationKey,
-    )
+    const data = Binary.xorCypher(Binary.concatBytes(header, entry, forkBitmap, ...forks), this.obfuscationKey)
 
     return Binary.concatBytes(this.obfuscationKey, data)
   }
@@ -311,11 +317,14 @@ export class MantarayNode {
     const targetAddress = targetAddressLength ? reader.read(targetAddressLength) : NULL_ADDRESS
     const node = new MantarayNode({ selfAddress, targetAddress, obfuscationKey })
     const forkBitmap = reader.read(32)
-    for (let i = 0; i < 256; i++) {
-      if (Binary.getBit(forkBitmap, i, 'LE')) {
-        const newFork = Fork.unmarshal(reader, selfAddress.length)
-        node.forks.set(i, newFork)
-        newFork.node.parent = node
+
+    if (targetAddressLength > 0) {
+      for (let i = 0; i < 256; i++) {
+        if (Binary.getBit(forkBitmap, i, 'LE')) {
+          const newFork = Fork.unmarshal(reader, selfAddress.length)
+          node.forks.set(i, newFork)
+          newFork.node.parent = node
+        }
       }
     }
 
@@ -331,6 +340,7 @@ export class MantarayNode {
     metadata?: Record<string, string> | null,
   ) {
     this.selfAddress = null
+    this.type = null
     path = path instanceof Uint8Array ? path : ENCODER.encode(path)
     debug('adding fork', { path: DECODER.decode(path), reference: new Reference(reference).represent() })
     // TODO: this should not be ignored
@@ -368,11 +378,13 @@ export class MantarayNode {
         tip.forks.set(remainingPath[0], fork)
         fork.node.parent = tip
         tip.selfAddress = null
+        tip.type = null
         tip = newFork.node
       } else {
         tip.forks.set(remainingPath[0], newFork)
         newFork.node.parent = tip
         tip.selfAddress = null
+        tip.type = null
         tip = newFork.node
       }
     }
@@ -383,6 +395,7 @@ export class MantarayNode {
    */
   removeFork(path: string | Uint8Array) {
     this.selfAddress = null
+    this.type = null
     path = path instanceof Uint8Array ? path : ENCODER.encode(path)
 
     if (path.length === 0) {
@@ -534,15 +547,22 @@ export class MantarayNode {
   determineType() {
     let type = 0
 
-    if (!Binary.equals(this.targetAddress, NULL_ADDRESS) || Binary.equals(this.path, PATH_SEPARATOR)) {
+    // Mirror Bee (pkg/manifest/mantaray/node.go): Add() marks every explicitly
+    // added leaf as a value (makeValue), even one with a null entry such as a
+    // metadata-only "/" node. In final-state terms a leaf (no forks) is always an
+    // added entry, so it is a value; a node with forks is a value only when it also
+    // carries an entry. The path-separator flag is set only when a separator occurs
+    // past the first byte (IndexRune > 0), so a prefix that merely starts with '/'
+    // does not qualify.
+    if (!Binary.equals(this.targetAddress, NULL_ADDRESS) || this.forks.size === 0) {
       type |= TYPE_VALUE
     }
 
     if (this.forks.size > 0) {
       type |= TYPE_EDGE
     }
 
-    if (Binary.indexOf(this.path, PATH_SEPARATOR) !== -1 && !Binary.equals(this.path, PATH_SEPARATOR)) {
+    if (Binary.indexOf(this.path, PATH_SEPARATOR) > 0) {
       type |= TYPE_WITH_PATH_SEPARATOR
     }
 

test/unit/manifest.spec.ts

@@ -1,3 +1,4 @@
+import { Binary } from 'cafe-utility'
 import { MantarayNode } from '../../src'
 import { arbitraryReference } from '../utils'
 
@@ -43,6 +44,43 @@ test('MantarayNode basic', () => {
   expect(node.collect()).toHaveLength(2)
 })
 
+test('directory node keeps its forks across a marshal/unmarshal round-trip', async () => {
+  const node = new MantarayNode()
+  node.addFork('/index.html', arbitraryReference())
+  node.addFork('/about.html', arbitraryReference())
+
+  const slash = node.forks.get('/'.charCodeAt(0))!.node
+  expect(ENCODER.encode('/')).toEqual(slash.path)
+  expect(slash.forks.size).toBe(2)
+
+  const bytes = await slash.marshal()
+  const restored = MantarayNode.unmarshalFromData(bytes, new Uint8Array(32))
+
+  expect(restored.forks.size).toBe(2)
+})
+
+test('reads a Bee-produced v0.2 directory node (real reference vector)', async () => {
+  // Generated by Bee's own mantaray MarshalBinary (bee/pkg/manifest/mantaray) for
+  // a directory node ("/") with two value forks and a zero obfuscation key.
+  // Byte 63 (the reference-size byte) is 0x20 = 32: Bee never emits 0 for a
+  // directory node, which is exactly what marshal() must reproduce.
+  const vector =
+    '00000000000000000000000000000000000000000000000000000000000000005768b3b6a7db56d21d1abff40d41cebfc83448fed8d7e9b06ec0d3b073f28f2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000202000000000000000000000000000000000000020a61626f75742e68746d6c0000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa020a696e6465782e68746d6c0000000000000000000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+  const data = Binary.hexToUint8Array(vector)
+
+  expect(data[63]).toBe(32) // Bee's reference-size byte for this directory node
+
+  const node = MantarayNode.unmarshalFromData(data, new Uint8Array(32))
+
+  expect(node.forks.size).toBe(2)
+  expect(node.forks.get('a'.charCodeAt(0))!.prefix).toEqual(ENCODER.encode('about.html'))
+  expect(node.forks.get('i'.charCodeAt(0))!.prefix).toEqual(ENCODER.encode('index.html'))
+
+  // An untouched node must re-marshal to the exact same bytes Bee produced,
+  // including each fork's preserved type byte (0x02 = value).
+  expect(await node.marshal()).toEqual(data)
+})
+
 test('MantarayNode long', () => {
   const htmlPath = '/Code/Swarm/bee-js/test/coverage/lcov-report/index.html'
   const jsPath = '/Code/Swarm/bee-js/test/coverage/lcov-report/index.js'