start-os/sdk/base/lib/s9pk/merkleArchive/directoryContents.ts

import { ArrayBufferReader, Entry } from "."
import { blake3 } from "@noble/hashes/blake3"
import { serializeVarint } from "./varint"
import { FileContents } from "./fileContents"
import { compare } from ".."

export class DirectoryContents {
  static readonly headerSize =
    8 + // position: u64 BE
    8 // size: u64 BE
  private constructor(readonly contents: { [name: string]: Entry }) {}
  static async deserialize(
    source: Blob,
    header: ArrayBufferReader,
    sighash: Uint8Array,
    maxSize: bigint,
  ): Promise<DirectoryContents> {
    const position = header.nextU64()
    const size = header.nextU64()
    if (size > maxSize) {
      throw new Error("size is greater than signed")
    }

    const tocReader = new ArrayBufferReader(
      await source
        .slice(Number(position), Number(position + size))
        .arrayBuffer(),
    )
    const len = tocReader.nextVarint()
    const entries: { [name: string]: Entry } = {}
    for (let i = 0; i < len; i++) {
      const name = tocReader.nextVarstring()
      const entry = await Entry.deserialize(source, tocReader)
      entries[name] = entry
    }

    const res = new DirectoryContents(entries)

    if (!compare(res.sighash(), sighash)) {
      throw new Error("hash sum does not match")
    }

    return res
  }
  sighash(): Uint8Array {
    const hasher = blake3.create({})
    const names = Object.keys(this.contents).sort()
    hasher.update(new Uint8Array(serializeVarint(names.length)))
    for (const name of names) {
      const entry = this.contents[name]
      const nameBuf = new TextEncoder().encode(name)
      hasher.update(new Uint8Array(serializeVarint(nameBuf.length)))
      hasher.update(nameBuf)
      hasher.update(new Uint8Array(entry.hash))
      const sizeBuf = new Uint8Array(8)
      new DataView(sizeBuf.buffer).setBigUint64(0, entry.size)
      hasher.update(sizeBuf)
      hasher.update(new Uint8Array([0]))
    }

    return hasher.digest()
  }
  getPath(path: string[]): Entry | null {
    if (path.length === 0) {
      return null
    }
    const next = this.contents[path[0]]
    const rest = path.slice(1)
    if (next === undefined) {
      return null
    }
    if (rest.length === 0) {
      return next
    }
    if (next.contents instanceof DirectoryContents) {
      return next.contents.getPath(rest)
    }
    return null
  }
}