@leofcoin/peernet 1.2.29 → 1.2.30

package/src/file-transfer.ts

@@ -0,0 +1,194 @@
+export type FileTransferState = 'idle' | 'running' | 'paused' | 'completed' | 'cancelled' | 'failed'
+
+export type FileTransferProgress = {
+  hash: string
+  state: FileTransferState
+  completedChunks: number
+  totalChunks: number
+  transferredBytes: number
+  totalBytes: number
+}
+
+type ProgressListener = (progress: FileTransferProgress) => void
+
+/** A resumable download. Completed chunks remain cached on the transfer instance. */
+export default class FileTransfer {
+  readonly hash: string
+  state: FileTransferState = 'idle'
+  result: Promise<Uint8Array>
+  error?: unknown
+
+  #fetch: (hash: string, index?: number) => Promise<Uint8Array | undefined>
+  #decode: (data: Uint8Array) => Promise<any>
+  #verify: (data: Uint8Array, hash: string) => Promise<boolean>
+  #pin?: (hash: string, data: Uint8Array) => Promise<any>
+  #verifyManifest: boolean
+  #concurrency: number
+  #stopped = false
+  #listeners = new Set<ProgressListener>()
+  #chunks = new Map<number, Uint8Array>()
+  #resumeWaiters: Array<() => void> = []
+  #resolve!: (value: Uint8Array) => void
+  #reject!: (reason?: unknown) => void
+  #totalChunks = 0
+  #totalBytes = 0
+  #started = false
+
+  constructor(options: {
+    hash: string
+    fetch: (hash: string, index?: number) => Promise<Uint8Array | undefined>
+    decode: (data: Uint8Array) => Promise<any>
+    verify: (data: Uint8Array, hash: string) => Promise<boolean>
+    pin?: (hash: string, data: Uint8Array) => Promise<any>
+    verifyManifest?: boolean
+    concurrency?: number
+  }) {
+    this.hash = options.hash
+    this.#fetch = options.fetch
+    this.#decode = options.decode
+    this.#verify = options.verify
+    this.#pin = options.pin
+    this.#verifyManifest = options.verifyManifest !== false
+    this.#concurrency = options.concurrency ?? 4
+    if (!Number.isSafeInteger(this.#concurrency) || this.#concurrency <= 0)
+      throw new TypeError('concurrency must be a positive integer')
+    this.result = new Promise((resolve, reject) => {
+      this.#resolve = resolve
+      this.#reject = reject
+    })
+  }
+
+  get progress(): FileTransferProgress {
+    let transferredBytes = 0
+    for (const chunk of this.#chunks.values()) transferredBytes += chunk.length
+    return {
+      hash: this.hash,
+      state: this.state,
+      completedChunks: this.#chunks.size,
+      totalChunks: this.#totalChunks,
+      transferredBytes,
+      totalBytes: this.#totalBytes
+    }
+  }
+
+  onProgress(listener: ProgressListener): () => void {
+    this.#listeners.add(listener)
+    listener(this.progress)
+    return () => this.#listeners.delete(listener)
+  }
+
+  start(): this {
+    if (!this.#started) {
+      this.#started = true
+      this.state = 'running'
+      this.#emit()
+      void this.#run()
+    }
+    return this
+  }
+
+  pause(): void {
+    if (this.state === 'running') {
+      this.state = 'paused'
+      this.#emit()
+    }
+  }
+
+  resume(): void {
+    if (this.state !== 'paused') return
+    this.state = 'running'
+    const waiters = this.#resumeWaiters.splice(0)
+    for (const resolve of waiters) resolve()
+    this.#emit()
+  }
+
+  cancel(): void {
+    if (this.state === 'completed' || this.state === 'failed' || this.state === 'cancelled') return
+    this.state = 'cancelled'
+    this.#stopped = true
+    const error = new Error(`Transfer ${this.hash} was cancelled`)
+    this.error = error
+    const waiters = this.#resumeWaiters.splice(0)
+    for (const resolve of waiters) resolve()
+    this.#reject(error)
+    this.#emit()
+  }
+
+  async #waitUntilRunning(): Promise<void> {
+    if (this.state === 'paused') await new Promise<void>((resolve) => this.#resumeWaiters.push(resolve))
+    if (this.state === 'cancelled') throw this.error
+  }
+
+  async #run(): Promise<void> {
+    try {
+      const manifestData = await this.#fetch(this.hash)
+      if (!manifestData) throw new Error(`Unable to download ${this.hash}`)
+      if (this.#verifyManifest && !(await this.#verify(manifestData, this.hash)))
+        throw new Error(`Manifest hash mismatch for ${this.hash}`)
+      const manifest = await this.#decode(manifestData)
+      if (this.#pin) await this.#pin(this.hash, manifestData)
+
+      if (!manifest.chunked) {
+        if (manifest.links?.length) throw new Error(`${this.hash} is a directory`)
+        const content = manifest.content || new Uint8Array()
+        this.#totalChunks = 1
+        this.#totalBytes = content.length
+        this.#chunks.set(0, content)
+        this.state = 'completed'
+        this.#resolve(content)
+        this.#emit()
+        return
+      }
+
+      const links = manifest.links || []
+      this.#totalChunks = links.length
+      this.#totalBytes =
+        Number(manifest.size) || links.reduce((sum: number, link: { size?: number }) => sum + (Number(link.size) || 0), 0)
+      this.#emit()
+
+      let nextIndex = 0
+      const worker = async () => {
+        while (!this.#stopped) {
+          await this.#waitUntilRunning()
+          const index = nextIndex++
+          if (index >= links.length) return
+          if (this.#chunks.has(index)) continue
+          const encoded = await this.#fetch(links[index].hash, index)
+          if (this.#stopped) return
+          if (!encoded) throw new Error(`Missing chunk ${index + 1}/${links.length}`)
+          if (!(await this.#verify(encoded, links[index].hash))) throw new Error(`Hash mismatch for chunk ${index + 1}`)
+          const chunkNode = await this.#decode(encoded)
+          const content = chunkNode.content || new Uint8Array()
+          this.#chunks.set(index, content)
+          if (this.#pin) await this.#pin(links[index].hash, encoded)
+          this.#emit()
+        }
+      }
+      await Promise.all(Array.from({ length: Math.min(this.#concurrency, links.length) }, () => worker()))
+
+      const output = new Uint8Array(this.#totalBytes)
+      let offset = 0
+      for (let index = 0; index < this.#totalChunks; index++) {
+        const chunk = this.#chunks.get(index)
+        if (!chunk) throw new Error(`Missing downloaded chunk ${index + 1}`)
+        output.set(chunk, offset)
+        offset += chunk.length
+      }
+      this.state = 'completed'
+      this.#resolve(offset === output.length ? output : output.slice(0, offset))
+      this.#emit()
+    } catch (error) {
+      if (this.state === 'cancelled') return
+      this.state = 'failed'
+      this.#stopped = true
+      this.error = error
+      this.#reject(error)
+      this.#emit()
+    }
+  }
+
+  #emit(): void {
+    const progress = this.progress
+    for (const listener of this.#listeners) listener(progress)
+  }
+}

package/src/peernet.ts

@@ -10,6 +10,18 @@ import { Storage as LeofcoinStorageClass } from '@leofcoin/storage'
 import { utils as codecUtils } from '@leofcoin/codecs'
 import Identity from './identity.js'
 import swarm from '@netpeer/swarm/client'
+import FileTransfer from './file-transfer.js'
+
+const DEFAULT_CHUNK_SIZE = 256 * 1024
+const DEFAULT_BLOCK_CHUNK_SIZE = 256 * 1024
+const DEFAULT_BLOCK_CHUNK_THRESHOLD = 1024 * 1024
+const DEFAULT_TRANSFER_CONCURRENCY = 4
+
+const adaptiveChunkSize = (size: number, minimum = DEFAULT_CHUNK_SIZE) => {
+  if (size >= 256 * 1024 * 1024) return Math.max(minimum, 4 * 1024 * 1024)
+  if (size >= 32 * 1024 * 1024) return Math.max(minimum, 1024 * 1024)
+  return minimum
+}
 
 globalThis.LeofcoinStorage = LeofcoinStorageClass
 
@@ -67,6 +79,9 @@ export default class Peernet {
   _peerHandler: PeerDiscovery
   protos: {}
   version
+  blockChunkSize: number
+  blockChunkThreshold: number
+  transferConcurrency: number
 
   #peerAttempts: { [key: string]: number } = {}
   private _inMemoryBroadcasts: any
@@ -94,6 +109,15 @@ export default class Peernet {
     this.stars = options.stars
     this.transport = options.transport
     this.version = options.version
+    this.blockChunkSize = options.blockChunkSize ?? DEFAULT_BLOCK_CHUNK_SIZE
+    this.blockChunkThreshold = options.blockChunkThreshold ?? DEFAULT_BLOCK_CHUNK_THRESHOLD
+    this.transferConcurrency = options.transferConcurrency ?? DEFAULT_TRANSFER_CONCURRENCY
+    if (!Number.isSafeInteger(this.blockChunkSize) || this.blockChunkSize <= 0)
+      throw new TypeError('blockChunkSize must be a positive integer')
+    if (!Number.isSafeInteger(this.blockChunkThreshold) || this.blockChunkThreshold < 0)
+      throw new TypeError('blockChunkThreshold must be a non-negative integer')
+    if (!Number.isSafeInteger(this.transferConcurrency) || this.transferConcurrency <= 0)
+      throw new TypeError('transferConcurrency must be a positive integer')
     const parts = this.network.split(':')
     this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet'
 
@@ -372,10 +396,31 @@ export default class Peernet {
  
    * @returns {Promise<string>} The hash that can be shared for direct download
    */
-  async broadcast(path: string, { content, links }: { content?: Uint8Array; links?: any[] }): Promise<string> {
+  async broadcast(
+    path: string,
+    { content, links, chunkSize }: { content?: Uint8Array; links?: any[]; chunkSize?: number }
+  ): Promise<string> {
+    chunkSize = chunkSize ?? (content ? adaptiveChunkSize(content.length) : DEFAULT_CHUNK_SIZE)
+    if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0) throw new TypeError('chunkSize must be a positive integer')
     let protoInput: any
-    if (content) protoInput = { path, content }
+    if (content && content.length > chunkSize) {
+      const chunkLinks = []
+      for (let offset = 0, index = 0; offset < content.length; offset += chunkSize, index++) {
+        const chunkNode = await new globalThis.peernet.protos['peernet-file']({
+          path: `${path}.part-${index}`,
+          content: content.slice(offset, Math.min(offset + chunkSize, content.length))
+        })
+        const chunkHash = await chunkNode.hash()
+        const chunkEncoded = await chunkNode.encoded
+        if (!this._inMemoryBroadcasts) this._inMemoryBroadcasts = new Map()
+        this._inMemoryBroadcasts.set(chunkHash, chunkEncoded)
+        await shareStore.put(chunkHash, chunkEncoded)
+        chunkLinks.push({ hash: chunkHash, path: String(index), size: chunkNode.decoded.content.length })
+      }
+      protoInput = { path, links: chunkLinks, size: content.length, chunkSize, chunked: true }
+    } else if (content) protoInput = { path, content, size: content.length }
     else if (links) protoInput = { path, links }
+    else throw new TypeError('broadcast requires content or links')
 
     const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput)
     const hash = await protoNode.hash()
@@ -390,6 +435,43 @@ export default class Peernet {
     return hash
   }
 
+  /** Create and immediately start a resumable, integrity-checked file download. */
+  download(hash: string, options: { pin?: boolean; autoStart?: boolean } = {}): FileTransfer {
+    const FileProto = globalThis.peernet.protos['peernet-file']
+    const transfer = new FileTransfer({
+      hash,
+      fetch: async (wantedHash, index) => {
+        if (wantedHash !== hash) {
+          const providers = Object.values(this.dht.providersFor(hash) || {}) as DHTProvider[]
+          for (const provider of providers) this.dht.addProvider(provider, wantedHash)
+        }
+        const store = await this.whichStore([...this.stores], wantedHash)
+        if (store && (await store.has(wantedHash))) return store.get(wantedHash)
+        const result = await this.requestData(wantedHash, undefined, { providerIndex: index })
+        return result
+      },
+      decode: async (encoded) => {
+        const node = await new FileProto(encoded)
+        await node.decode()
+        if (node.decoded?.chunked) {
+          const providers = Object.values(this.dht.providersFor(hash) || {}) as DHTProvider[]
+          for (const link of node.decoded.links || []) {
+            for (const provider of providers) this.dht.addProvider(provider, link.hash)
+          }
+        }
+        return node.decoded
+      },
+      concurrency: this.transferConcurrency,
+      verify: async (encoded, expectedHash) => {
+        const node = await new FileProto(encoded)
+        return (await node.hash()) === expectedHash
+      },
+      pin: options.pin ? (chunkHash, encoded) => dataStore.put(chunkHash, encoded) : undefined
+    })
+    if (options.autoStart !== false) transfer.start()
+    return transfer
+  }
+
   async handleData(peer, id, proto) {
     let { hash, store } = proto.decoded
     let data
@@ -400,16 +482,9 @@ export default class Peernet {
         if (typeof hash === 'function') {
           resolvedHash = await hash()
         }
-        // Decode the stored proto to extract the content or links
-        const FileProto = globalThis.peernet.protos['peernet-file']
-        const fileProto = await new FileProto(data)
-        await fileProto.decode()
-        const { content, links } = fileProto.decoded
-        console.log(links)
-
         data = await new globalThis.peernet.protos['peernet-data-response']({
           hash: resolvedHash,
-          data: links || content
+          data
         })
 
         const node = await this.prepareMessage(data)
@@ -573,18 +648,88 @@ export default class Peernet {
   get block() {
     return {
       get: async (hash: string) => {
-        const data = await blockStore.has(hash)
-        if (data) return blockStore.get(hash)
-        return this.requestData(hash, 'block')
+        return this.#createBlockTransfer(hash).result
       },
       put: async (hash: string, data: Uint8Array) => {
         if (await blockStore.has(hash)) return
+        if (data.length > this.blockChunkThreshold) return this.#putChunkedBlock(hash, data)
         return await blockStore.put(hash, data)
       },
-      has: async (hash: string) => await blockStore.has(hash)
+      has: async (hash: string) => await blockStore.has(hash),
+      download: (hash: string, options: { autoStart?: boolean } = {}) => this.#createBlockTransfer(hash, options)
     }
   }
 
+  async #putChunkedBlock(hash: string, data: Uint8Array) {
+    const links = []
+    const FileProto = globalThis.peernet.protos['peernet-file']
+    const chunkSize = adaptiveChunkSize(data.length, this.blockChunkSize)
+    for (let offset = 0, index = 0; offset < data.length; offset += chunkSize, index++) {
+      const content = data.slice(offset, Math.min(offset + chunkSize, data.length))
+      const chunk = new FileProto({ path: `block-${hash}.part-${index}`, content })
+      const chunkHash = await chunk.hash()
+      await blockStore.put(chunkHash, chunk.encoded)
+      links.push({ hash: chunkHash, path: String(index).padStart(12, '0'), size: content.length })
+    }
+
+    const manifest = new FileProto({
+      path: `block-${hash}`,
+      links,
+      size: data.length,
+      chunkSize,
+      chunked: true,
+      kind: 'block',
+      blockHash: hash
+    })
+    return blockStore.put(hash, manifest.encoded)
+  }
+
+  #createBlockTransfer(hash: string, options: { autoStart?: boolean } = {}): FileTransfer {
+    const FileProto = globalThis.peernet.protos['peernet-file']
+    const fetch = async (wantedHash: string, index?: number) => {
+      if (wantedHash !== hash) {
+        const providers = Object.values(this.dht.providersFor(hash) || {}) as DHTProvider[]
+        for (const provider of providers) this.dht.addProvider(provider, wantedHash)
+      }
+      if (await blockStore.has(wantedHash)) return blockStore.get(wantedHash)
+      const result = await this.requestData(wantedHash, 'block', { providerIndex: index })
+      return result
+    }
+    const transfer = new FileTransfer({
+      hash,
+      fetch,
+      decode: async (encoded) => {
+        let node
+        try {
+          node = new FileProto(encoded)
+          await node.decode()
+        } catch {
+          // A normal block is intentionally not a peernet-file envelope.
+          return { content: encoded }
+        }
+        if (node.decoded?.kind === 'block') {
+          if (node.decoded.blockHash !== hash) throw new Error(`Block manifest hash mismatch for ${hash}`)
+          const providers = Object.values(this.dht.providersFor(hash) || {}) as DHTProvider[]
+          for (const link of node.decoded.links || []) {
+            for (const provider of providers) this.dht.addProvider(provider, link.hash)
+          }
+          return node.decoded
+        }
+        if (node.decoded?.path?.startsWith(`block-${hash}.part-`)) return node.decoded
+        return { content: encoded }
+      },
+      verify: async (encoded, expectedHash) => {
+        const node = new FileProto(encoded)
+        return (await node.hash()) === expectedHash
+      },
+      verifyManifest: false,
+      concurrency: this.transferConcurrency,
+      pin: (wantedHash, encoded) => blockStore.put(wantedHash, encoded)
+    })
+    if (options.autoStart !== false) transfer.start()
+    return transfer
+  }
+
   get transaction() {
     return {
       get: async (hash: string) => {
@@ -600,13 +745,17 @@ export default class Peernet {
     }
   }
 
-  async requestData(hash, store) {
+  async requestData(hash, store, options: { providerIndex?: number } = {}) {
     try {
       const providers = await this.providersFor(hash)
       if (!providers || (providers && Object.keys(providers).length === 0)) throw nothingFoundError(hash)
       debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`)
       // get closest peer on earth
-      let closestPeer: DHTProvider = await this.dht.closestPeer(Object.values(providers))
+      const providerValues = Object.values(providers) as DHTProvider[]
+      let closestPeer: DHTProvider =
+        options.providerIndex === undefined
+          ? await this.dht.closestPeer(providerValues)
+          : providerValues[options.providerIndex % providerValues.length]
       // fallback to first provider if no closest peer found
       if (!closestPeer || !closestPeer.id) closestPeer = Object.values(providers)[0]
 
@@ -618,7 +767,7 @@ export default class Peernet {
 
       if (!peer || !peer?.connected) {
         this.dht.removeProvider(id, hash)
-        return this.requestData(hash, store?.name || store)
+        return this.requestData(hash, store?.name || store, options)
       }
 
       let data = await new globalThis.peernet.protos['peernet-data']({
@@ -661,7 +810,7 @@ export default class Peernet {
 
           if (this.#peerAttempts[id] === undefined) this.#peerAttempts[id] = 0
           this.#peerAttempts[id]++
-          return this.requestData(hash, store?.name || store)
+          return this.requestData(hash, store?.name || store, options)
         }
 
         // this.put(hash, proto.decoded.data)
@@ -843,16 +992,8 @@ export default class Peernet {
   }
 
   async cat(hash, options) {
-    let data
-    const has = await dataStore.has(hash)
-    data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data')
-    if (!data) throw nothingFoundError(hash)
-    const node = await new globalThis.peernet.protos['peernet-file'](data)
-    await node.decode()
-
-    if (node.decoded?.links.length > 0) throw new Error(`${hash} is a directory`)
-    if (options?.pin) await dataStore.put(hash, node.encoded)
-    return node.decoded.content
+    const transfer = this.download(hash, { pin: options?.pin })
+    return transfer.result
   }
 
   /**
@@ -969,3 +1110,4 @@ export default class Peernet {
 }
 
 globalThis.Peernet = Peernet
+export { FileTransfer }

package/src/proto/file.proto.js

@@ -1,5 +1,10 @@
 export default {
   path: String(),
   'content?': new Uint8Array(),
-  'links?': []
+  'links?': [],
+  'size?': Number(),
+  'chunkSize?': Number(),
+  'chunked?': Boolean(),
+  'kind?': String(),
+  'blockHash?': String()
 }

package/test/file-transfer.test.js

@@ -0,0 +1,81 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { FileTransfer } from '../exports/peernet.js'
+
+const bytes = (value) => new TextEncoder().encode(JSON.stringify(value))
+const decode = async (value) => JSON.parse(new TextDecoder().decode(value))
+
+test('chunk transfer pauses, resumes, reassembles, and reports progress', async () => {
+  const objects = new Map([
+    ['manifest', bytes({ chunked: true, size: 6, links: [{ hash: 'a', size: 2 }, { hash: 'b', size: 2 }, { hash: 'c', size: 2 }] })],
+    ['a', bytes({ content: [1, 2] })],
+    ['b', bytes({ content: [3, 4] })],
+    ['c', bytes({ content: [5, 6] })]
+  ])
+  const fetched = []
+  const transfer = new FileTransfer({
+    hash: 'manifest',
+    fetch: async (hash) => {
+      fetched.push(hash)
+      return objects.get(hash)
+    },
+    decode: async (encoded) => {
+      const value = await decode(encoded)
+      if (value.content) value.content = new Uint8Array(value.content)
+      return value
+    },
+    verify: async (_encoded, hash) => objects.has(hash)
+  })
+
+  transfer.pause()
+  transfer.start()
+  transfer.pause()
+  await new Promise((resolve) => setTimeout(resolve, 10))
+  assert.deepEqual(fetched, ['manifest'])
+  assert.equal(transfer.state, 'paused')
+
+  transfer.resume()
+  assert.deepEqual(await transfer.result, new Uint8Array([1, 2, 3, 4, 5, 6]))
+  assert.equal(transfer.state, 'completed')
+  assert.equal(transfer.progress.completedChunks, 3)
+  assert.equal(transfer.progress.transferredBytes, 6)
+})
+
+test('chunk transfer rejects failed integrity checks', async () => {
+  const transfer = new FileTransfer({
+    hash: 'bad',
+    fetch: async () => bytes({ content: [1] }),
+    decode,
+    verify: async () => false
+  }).start()
+
+  await assert.rejects(transfer.result, /Manifest hash mismatch/)
+  assert.equal(transfer.state, 'failed')
+})
+
+test('chunk transfer pipelines up to the configured concurrency', async () => {
+  const links = Array.from({ length: 8 }, (_, index) => ({ hash: `chunk-${index}`, size: 1 }))
+  let active = 0
+  let maximumActive = 0
+  const transfer = new FileTransfer({
+    hash: 'manifest',
+    concurrency: 4,
+    fetch: async (hash) => {
+      if (hash === 'manifest') return bytes({ chunked: true, size: 8, links })
+      active += 1
+      maximumActive = Math.max(maximumActive, active)
+      await new Promise((resolve) => setTimeout(resolve, 5))
+      active -= 1
+      return bytes({ content: [Number(hash.split('-')[1])] })
+    },
+    decode: async (encoded) => {
+      const value = await decode(encoded)
+      if (value.content) value.content = new Uint8Array(value.content)
+      return value
+    },
+    verify: async () => true
+  }).start()
+
+  assert.deepEqual(await transfer.result, new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]))
+  assert.equal(maximumActive, 4)
+})

package/test/peernet.test.js

@@ -187,6 +187,31 @@ test('block object provides get/put/has', () => {
   assert.equal(typeof blockObj.has, 'function')
 })
 
+test('large blocks are chunked internally and reconstructed transparently', async () => {
+  const previousThreshold = peernet.blockChunkThreshold
+  const previousChunkSize = peernet.blockChunkSize
+  peernet.blockChunkThreshold = 512
+  peernet.blockChunkSize = 256
+  try {
+    const hash = `chunked-block-${Date.now()}`
+    const block = new Uint8Array(1537)
+    for (let index = 0; index < block.length; index++) block[index] = index % 251
+
+    await peernet.block.put(hash, block)
+    const stored = await globalThis.blockStore.get(hash)
+    const manifest = new peernet.protos['peernet-file'](stored)
+    await manifest.decode()
+
+    assert.equal(manifest.decoded.kind, 'block')
+    assert.equal(manifest.decoded.blockHash, hash)
+    assert.equal(manifest.decoded.links.length, 7)
+    assert.deepEqual(await peernet.block.get(hash), block)
+  } finally {
+    peernet.blockChunkThreshold = previousThreshold
+    peernet.blockChunkSize = previousChunkSize
+  }
+})
+
 test('transaction object provides get/put/has', () => {
   const txObj = peernet.transaction
   assert.equal(typeof txObj.get, 'function')
@@ -329,7 +354,10 @@ test('in-memory broadcast and handleData returns correct data', async () => {
   const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
   const decodedProto = await new DataResponseProto(sentNode.data)
   await decodedProto.decode()
-  const decodedContent = new TextDecoder().decode(decodedProto.decoded.data)
+  const FileProto = globalThis.peernet.protos['peernet-file']
+  const decodedFile = new FileProto(decodedProto.decoded.data)
+  await decodedFile.decode()
+  const decodedContent = new TextDecoder().decode(decodedFile.decoded.content)
   assert.equal(decodedProto.decoded.hash, hash)
   assert.equal(decodedContent, testString)
 })
@@ -362,7 +390,8 @@ test('in-memory broadcast and handleData supports large binary data', async () =
   const decodedProto = await new DataResponseProto(sentNode.data)
   await decodedProto.decode()
   assert.equal(decodedProto.decoded.hash, hash)
-  const receivedBuffer = Buffer.from(decodedProto.decoded.data)
+  const transfer = peernet.download(hash)
+  const receivedBuffer = Buffer.from(await transfer.result)
   const originalBuffer = Buffer.from(largeBuffer)
   assert.equal(Buffer.compare(receivedBuffer, originalBuffer), 0)
 })