@snaha/swarm-id 0.0.1

package/src/proxy/mantaray-encrypted.ts

@@ -0,0 +1,78 @@
+import type { MantarayNode } from "@ethersphere/bee-js"
+import {
+  makeEncryptedContentAddressedChunk,
+  type EncryptedChunk,
+} from "../chunk"
+import { uint8ArrayToHex } from "../utils/hex"
+
+/**
+ * Upload callback type for saveMantarayTreeRecursivelyEncrypted
+ *
+ * @param encryptedData - The encrypted chunk data to upload
+ * @param address - The 32-byte address of the encrypted chunk
+ * @param isRoot - Whether this is the root node
+ * @returns Upload result with optional tag UID
+ */
+export type EncryptedUploadCallback = (
+  encryptedData: Uint8Array,
+  address: Uint8Array,
+  isRoot: boolean,
+) => Promise<{ tagUid?: number }>
+
+/**
+ * Save a Mantaray tree with encryption by uploading bottom-up
+ *
+ * This mirrors saveMantarayTreeRecursively but encrypts each manifest node
+ * and creates 64-byte encrypted references (address + encryption key).
+ *
+ * @param node - Root Mantaray node to save
+ * @param uploadFn - Callback to upload each encrypted chunk
+ * @returns Root reference (128 hex chars = 64 bytes) and optional tag UID
+ */
+export async function saveMantarayTreeRecursivelyEncrypted(
+  node: MantarayNode,
+  uploadFn: EncryptedUploadCallback,
+): Promise<{ rootReference: string; tagUid?: number }> {
+  async function saveRecursively(
+    current: MantarayNode,
+    isRoot: boolean,
+  ): Promise<{ tagUid?: number }> {
+    // Process children first (bottom-up)
+    for (const fork of current.forks.values()) {
+      await saveRecursively(fork.node, false)
+    }
+
+    // Marshal the current node
+    const data = await current.marshal()
+
+    // Encrypt the manifest chunk
+    const encryptedChunk: EncryptedChunk =
+      makeEncryptedContentAddressedChunk(data)
+
+    // DEBUG: Trace encryption key presence
+
+    // Upload the encrypted chunk data
+    const result = await uploadFn(
+      encryptedChunk.data,
+      encryptedChunk.address.toUint8Array(),
+      isRoot,
+    )
+
+    // Create 64-byte reference: address + encryption key
+    const encryptedRef = new Uint8Array(64)
+    encryptedRef.set(encryptedChunk.address.toUint8Array(), 0)
+    encryptedRef.set(encryptedChunk.encryptionKey, 32)
+
+    // Set the node's self address to the full 64-byte encrypted reference
+    current.selfAddress = encryptedRef
+
+    return result
+  }
+
+  const result = await saveRecursively(node, true)
+
+  return {
+    rootReference: uint8ArrayToHex(node.selfAddress!),
+    tagUid: result.tagUid,
+  }
+}

package/src/proxy/mantaray.ts

@@ -0,0 +1,104 @@
+import { MantarayNode } from "@ethersphere/bee-js"
+import type { Bee, BeeRequestOptions } from "@ethersphere/bee-js"
+import { hexToUint8Array, uint8ArrayToHex } from "../utils/hex"
+import { downloadDataWithChunkAPI } from "./download-data"
+
+/**
+ * Upload callback type for saveMantarayTreeRecursively
+ */
+export type UploadCallback = (
+  data: Uint8Array,
+  isRoot: boolean,
+) => Promise<{ reference: string; tagUid?: number }>
+
+/**
+ * Save a Mantaray tree by uploading bottom-up
+ *
+ * This mirrors MantarayNode.saveRecursively() but allows custom upload logic
+ * and uses Bee's returned references to avoid address mismatches.
+ */
+export async function saveMantarayTreeRecursively(
+  node: MantarayNode,
+  uploadFn: UploadCallback,
+): Promise<{ rootReference: string; tagUid?: number }> {
+  async function saveRecursively(
+    current: MantarayNode,
+    isRoot: boolean,
+  ): Promise<{ reference: string; tagUid?: number }> {
+    for (const fork of current.forks.values()) {
+      await saveRecursively(fork.node, false)
+    }
+
+    const data = await current.marshal()
+    const result = await uploadFn(data, isRoot)
+    current.selfAddress = hexToUint8Array(result.reference)
+
+    return result
+  }
+
+  const result = await saveRecursively(node, true)
+
+  return {
+    rootReference: result.reference,
+    tagUid: result.tagUid,
+  }
+}
+
+/**
+ * Load a Mantaray tree using only the chunk API.
+ *
+ * This avoids /bytes and supports encrypted references.
+ */
+export async function loadMantarayTreeWithChunkAPI(
+  bee: Bee,
+  rootReference: string,
+  requestOptions?: BeeRequestOptions,
+): Promise<MantarayNode> {
+  const rootData = await downloadDataWithChunkAPI(
+    bee,
+    rootReference,
+    undefined,
+    undefined,
+    requestOptions,
+  )
+  const root = MantarayNode.unmarshalFromData(
+    rootData,
+    hexToUint8Array(rootReference),
+  )
+
+  async function loadRecursively(node: MantarayNode): Promise<void> {
+    for (const fork of node.forks.values()) {
+      if (!fork.node.selfAddress) {
+        throw new Error("Fork node selfAddress is not set")
+      }
+
+      const childRef = uint8ArrayToHex(fork.node.selfAddress)
+      const childData = await downloadDataWithChunkAPI(
+        bee,
+        childRef,
+        undefined,
+        undefined,
+        requestOptions,
+      )
+      const childNode = MantarayNode.unmarshalFromData(
+        childData,
+        fork.node.selfAddress,
+      )
+
+      fork.node.targetAddress = childNode.targetAddress
+      fork.node.forks = childNode.forks
+      fork.node.obfuscationKey = childNode.obfuscationKey
+      fork.node.path = fork.prefix
+      fork.node.parent = node
+
+      for (const nestedFork of fork.node.forks.values()) {
+        nestedFork.node.parent = fork.node
+      }
+
+      await loadRecursively(fork.node)
+    }
+  }
+
+  await loadRecursively(root)
+  return root
+}

package/src/proxy/types.ts

@@ -0,0 +1,32 @@
+import type { Bee, Stamper } from "@ethersphere/bee-js"
+
+/**
+ * Upload context shared across handlers
+ */
+export interface UploadContext {
+  bee: Bee
+  stamper: Stamper
+}
+
+/**
+ * Upload progress information
+ */
+export interface UploadProgress {
+  total: number // Total chunks to upload
+  processed: number // Chunks uploaded so far
+}
+
+/**
+ * Chunk reference (32-byte address)
+ */
+export interface ChunkReference {
+  address: Uint8Array // 32-byte chunk address
+}
+
+/**
+ * Encrypted chunk reference (64-byte reference: address + encryption key)
+ */
+export interface EncryptedChunkReference {
+  address: Uint8Array // 32-byte chunk address
+  key: Uint8Array // 32-byte encryption key
+}

package/src/proxy/upload-data.ts

@@ -0,0 +1,189 @@
+import { Reference } from "@ethersphere/bee-js"
+import type {
+  Bee,
+  BeeRequestOptions,
+  Stamper,
+  UploadOptions,
+  UploadResult,
+} from "@ethersphere/bee-js"
+import { makeContentAddressedChunk, type ContentAddressedChunk } from "../chunk"
+import { splitDataIntoChunks, buildMerkleTree } from "./chunking"
+import type { UploadContext, UploadProgress, ChunkReference } from "./types"
+
+/**
+ * Simple Uint8ArrayWriter implementation for ChunkAdapter
+ */
+class SimpleUint8ArrayWriter {
+  cursor: number = 0
+  buffer: Uint8Array
+
+  constructor(buffer: Uint8Array) {
+    this.buffer = buffer
+  }
+
+  write(_reader: unknown): number {
+    throw new Error("SimpleUint8ArrayWriter.write() not implemented")
+  }
+
+  max(): number {
+    return this.buffer.length
+  }
+}
+
+/**
+ * Adapter to convert bee-js Chunk to cafe-utility Chunk interface
+ * This allows the Stamper to work with content-addressed chunks
+ */
+class ChunkAdapter {
+  span: bigint
+  writer: SimpleUint8ArrayWriter
+
+  constructor(private chunk: ContentAddressedChunk) {
+    this.span = chunk.span.toBigInt()
+    this.writer = new SimpleUint8ArrayWriter(chunk.data)
+  }
+
+  hash(): Uint8Array {
+    return this.chunk.address.toUint8Array()
+  }
+
+  build(): Uint8Array {
+    return this.chunk.data
+  }
+}
+
+/**
+ * Upload data with client-side signing
+ * Handles chunking, merkle tree building, and progress reporting
+ */
+export async function uploadDataWithSigning(
+  context: UploadContext,
+  data: Uint8Array,
+  options?: UploadOptions,
+  onProgress?: (progress: UploadProgress) => void,
+  requestOptions?: BeeRequestOptions,
+): Promise<{ reference: string; tagUid?: number }> {
+  const { bee, stamper } = context
+
+  // Create a tag for tracking upload progress (required for fast deferred uploads)
+  let tag: number | undefined = options?.tag
+  if (!tag) {
+    const tagResponse = await bee.createTag()
+    tag = tagResponse.uid
+  }
+
+  // Step 1: Split data into chunks
+  const chunkPayloads = splitDataIntoChunks(data)
+  let totalChunks = chunkPayloads.length
+  let processedChunks = 0
+
+  // Progress callback helper
+  const reportProgress = () => {
+    if (onProgress) {
+      onProgress({ total: totalChunks, processed: processedChunks })
+    }
+  }
+
+  // Step 2: Process leaf chunks
+  const chunkRefs: ChunkReference[] = []
+
+  // Merge tag into options for all chunk uploads
+  const uploadOptionsWithTag = { ...options, tag }
+
+  for (const payload of chunkPayloads) {
+    // Create content-addressed chunk
+    const chunk = makeContentAddressedChunk(payload)
+
+    // Store reference
+    chunkRefs.push({
+      address: chunk.address.toUint8Array(),
+    })
+
+    // Upload chunk with signing
+    await uploadSingleChunk(
+      bee,
+      stamper,
+      chunk,
+      uploadOptionsWithTag,
+      requestOptions,
+    )
+
+    processedChunks++
+    reportProgress()
+  }
+
+  // Step 3: Build merkle tree (if multiple chunks)
+  let rootReference: Reference
+
+  if (chunkRefs.length === 1) {
+    // Single chunk - use direct reference
+    rootReference = new Reference(chunkRefs[0].address)
+  } else {
+    // Multiple chunks - build tree
+
+    rootReference = await buildMerkleTree(
+      chunkRefs,
+      async (intermediateChunk) => {
+        await uploadSingleChunk(
+          bee,
+          stamper,
+          intermediateChunk,
+          uploadOptionsWithTag,
+          requestOptions,
+        )
+
+        // Count intermediate chunks in progress
+        totalChunks++
+        processedChunks++
+        reportProgress()
+      },
+    )
+  }
+
+  // Return result
+  return {
+    reference: rootReference.toHex(),
+    tagUid: tag,
+  }
+}
+
+/**
+ * Upload a single chunk with optional signing
+ * Returns UploadResult with Bee's actual stored reference for verification
+ */
+export async function uploadSingleChunk(
+  bee: Bee,
+  stamper: Stamper | undefined,
+  chunk: ContentAddressedChunk,
+  options?: UploadOptions,
+  requestOptions?: BeeRequestOptions,
+): Promise<UploadResult> {
+  // Use non-deferred mode for faster uploads (returns immediately)
+  // Note: pinning is incompatible with deferred mode, so disable it
+  const uploadOptions = { deferred: false, pin: false, ...options }
+
+  if (stamper) {
+    // Client-side signing - use adapter for cafe-utility Chunk interface
+    const chunkAdapter = new ChunkAdapter(chunk)
+    const envelope = stamper.stamp(chunkAdapter)
+    const result = await bee.uploadChunk(
+      envelope,
+      chunk.data,
+      uploadOptions,
+      requestOptions,
+    )
+
+    // Verify address match between locally computed and Bee's response
+    const localAddress = chunk.address.toHex()
+    const beeAddress = result.reference.toHex()
+    if (localAddress !== beeAddress) {
+      console.error(
+        `[ADDRESS MISMATCH] local=${localAddress} bee=${beeAddress}`,
+      )
+    }
+
+    return result
+  } else {
+    throw new Error("No stamper or batch ID available")
+  }
+}