@helia/bitswap 0.0.0 → 1.0.0-59de059

package/src/index.ts

@@ -9,10 +9,9 @@
 import { Bitswap as BitswapClass } from './bitswap.js'
 import type { BitswapNetworkNotifyProgressEvents, BitswapNetworkWantProgressEvents } from './network.js'
 import type { WantType } from './pb/message.js'
-import type { CreateSessionOptions } from '@helia/interface'
+import type { BlockBroker, CreateSessionOptions } from '@helia/interface'
 import type { Routing } from '@helia/interface/routing'
 import type { Libp2p, AbortOptions, Startable, ComponentLogger, Metrics, PeerId } from '@libp2p/interface'
-import type { PeerSet } from '@libp2p/peer-collections'
 import type { Blockstore } from 'interface-blockstore'
 import type { CID } from 'multiformats/cid'
 import type { MultihashHasher } from 'multiformats/hashes/interface'
@@ -29,52 +28,12 @@ export type BitswapWantBlockProgressEvents =
   ProgressEvent<'bitswap:want-block:block', CID> |
   BitswapNetworkWantProgressEvents
 
-/**
- * A bitswap session is a network overlay consisting of peers that all have the
- * first block in a file. Subsequent requests will only go to these peers.
- */
-export interface BitswapSession {
-  /**
-   * The peers in this session
-   */
-  peers: PeerSet
-
-  /**
-   * Fetch an additional CID from this DAG
-   */
-  want(cid: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<Uint8Array>
-}
-
 export interface WantListEntry {
   cid: CID
   priority: number
   wantType: WantType
 }
 
-export interface CreateBitswapSessionOptions extends CreateSessionOptions<BitswapWantProgressEvents> {
-  /**
-   * If true, query connected peers before searching for providers via
-   * Helia routers
-   *
-   * @default true
-   */
-  queryConnectedPeers?: boolean
-
-  /**
-   * If true, search for providers via Helia routers to query for the root CID
-   *
-   * @default true
-   */
-  queryRoutingPeers?: boolean
-
-  /**
-   * The priority to use when querying availability of the root CID
-   *
-   * @default 1
-   */
-  priority?: number
-}
-
 export interface Bitswap extends Startable {
   /**
    * Returns the current state of the wantlist
@@ -100,7 +59,7 @@ export interface Bitswap extends Startable {
   /**
    * Start a session to retrieve a file from the network
    */
-  createSession(root: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<BitswapSession>
+  createSession(options?: CreateSessionOptions<BitswapWantProgressEvents>): Required<Pick<BlockBroker<BitswapWantProgressEvents>, 'retrieve'>>
 }
 
 export interface MultihashHasherLoader {
@@ -158,14 +117,6 @@ export interface BitswapOptions {
    */
   protocol?: string
 
-  /**
-   * When a new peer connects, sending our WantList should complete within this
-   * many ms
-   *
-   * @default 5000
-   */
-  messageSendTimeout?: number
-
   /**
    * When sending want list updates to peers, how many messages to send at once
    *
@@ -208,6 +159,28 @@ export interface BitswapOptions {
    * @default 1024
    */
   maxSizeReplaceHasWithBlock?: number
+
+  /**
+   * The maximum size in bytes of a message that we will send. If a message is
+   * larger than this (due to lots of blocks or wantlist entries) it will be
+   * broken up into several smaller messages that are under this size.
+   *
+   * @see https://github.com/ipfs/boxo/blob/eeea414587350401b6b804f0574ed8436833331d/bitswap/client/internal/messagequeue/messagequeue.go#L33
+   *
+   * @default 2097152
+   */
+  maxOutgoingMessageSize?: number
+
+  /**
+   * The maximum size in bytes of an incoming message that we will process.
+   *
+   * Messages larger than this will cause the incoming stream to be reset.
+   *
+   * Defaults to `maxOutgoingMessageSize`
+   *
+   * @default 2097152
+   */
+  maxIncomingMessageSize?: number
 }
 
 export const createBitswap = (components: BitswapComponents, options: BitswapOptions = {}): Bitswap => {

package/src/network.ts

@@ -1,56 +1,25 @@
 import { CodeError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { PeerQueue, type PeerQueueJobOptions } from '@libp2p/utils/peer-queue'
-import { Circuit } from '@multiformats/multiaddr-matcher'
-import { anySignal } from 'any-signal'
-import debug from 'debug'
 import drain from 'it-drain'
 import * as lp from 'it-length-prefixed'
-import { lpStream } from 'it-length-prefixed-stream'
 import map from 'it-map'
 import { pipe } from 'it-pipe'
 import take from 'it-take'
-import { base64 } from 'multiformats/bases/base64'
-import { CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
 import { raceEvent } from 'race-event'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { BITSWAP_120, DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS, DEFAULT_MAX_PROVIDERS_PER_REQUEST, DEFAULT_MESSAGE_RECEIVE_TIMEOUT, DEFAULT_MESSAGE_SEND_TIMEOUT, DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS } from './constants.js'
+import { BITSWAP_120, DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_INCOMING_MESSAGE_SIZE, DEFAULT_MAX_OUTBOUND_STREAMS, DEFAULT_MAX_OUTGOING_MESSAGE_SIZE, DEFAULT_MAX_PROVIDERS_PER_REQUEST, DEFAULT_MESSAGE_RECEIVE_TIMEOUT, DEFAULT_MESSAGE_SEND_CONCURRENCY, DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS } from './constants.js'
 import { BitswapMessage } from './pb/message.js'
+import { mergeMessages } from './utils/merge-messages.js'
+import { splitMessage } from './utils/split-message.js'
 import type { WantOptions } from './bitswap.js'
 import type { MultihashHasherLoader } from './index.js'
-import type { Block, BlockPresence, WantlistEntry } from './pb/message.js'
+import type { Block } from './pb/message.js'
 import type { Provider, Routing } from '@helia/interface/routing'
-import type { Libp2p, AbortOptions, Connection, PeerId, IncomingStreamData, Topology, MetricGroup, ComponentLogger, Metrics, IdentifyResult } from '@libp2p/interface'
+import type { Libp2p, AbortOptions, Connection, PeerId, IncomingStreamData, Topology, ComponentLogger, IdentifyResult, Counter } from '@libp2p/interface'
 import type { Logger } from '@libp2p/logger'
+import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
-// Add a formatter for a bitswap message
-debug.formatters.B = (b?: BitswapMessage): string => {
-  if (b == null) {
-    return 'undefined'
-  }
-
-  return JSON.stringify({
-    blocks: b.blocks?.map(b => ({
-      data: `${uint8ArrayToString(b.data, 'base64').substring(0, 10)}...`,
-      prefix: uint8ArrayToString(b.prefix, 'base64')
-    })),
-    blockPresences: b.blockPresences?.map(p => ({
-      ...p,
-      cid: CID.decode(p.cid).toString()
-    })),
-    wantlist: b.wantlist == null
-      ? undefined
-      : {
-          full: b.wantlist.full,
-          entries: b.wantlist.entries.map(e => ({
-            ...e,
-            cid: CID.decode(e.cid).toString()
-          }))
-        }
-  }, null, 2)
-}
-
 export type BitswapNetworkProgressEvents =
   ProgressEvent<'bitswap:network:dial', PeerId>
 
@@ -69,17 +38,17 @@ export interface NetworkInit {
   maxInboundStreams?: number
   maxOutboundStreams?: number
   messageReceiveTimeout?: number
-  messageSendTimeout?: number
   messageSendConcurrency?: number
   protocols?: string[]
   runOnTransientConnections?: boolean
+  maxOutgoingMessageSize?: number
+  maxIncomingMessageSize?: number
 }
 
 export interface NetworkComponents {
   routing: Routing
   logger: ComponentLogger
   libp2p: Libp2p
-  metrics?: Metrics
 }
 
 export interface BitswapMessageEventDetail {
@@ -107,10 +76,11 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
   private readonly maxOutboundStreams: number
   private readonly messageReceiveTimeout: number
   private registrarIds: string[]
-  private readonly metrics?: { blocksSent: MetricGroup, dataSent: MetricGroup }
+  private readonly metrics: { blocksSent?: Counter, dataSent?: Counter }
   private readonly sendQueue: PeerQueue<void, SendMessageJobOptions>
-  private readonly messageSendTimeout: number
   private readonly runOnTransientConnections: boolean
+  private readonly maxOutgoingMessageSize: number
+  private readonly maxIncomingMessageSize: number
 
   constructor (components: NetworkComponents, init: NetworkInit = {}) {
     super()
@@ -127,20 +97,18 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     this.maxInboundStreams = init.maxInboundStreams ?? DEFAULT_MAX_INBOUND_STREAMS
     this.maxOutboundStreams = init.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS
     this.messageReceiveTimeout = init.messageReceiveTimeout ?? DEFAULT_MESSAGE_RECEIVE_TIMEOUT
-    this.messageSendTimeout = init.messageSendTimeout ?? DEFAULT_MESSAGE_SEND_TIMEOUT
     this.runOnTransientConnections = init.runOnTransientConnections ?? DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS
-
-    if (components.metrics != null) {
-      this.metrics = {
-        blocksSent: components.metrics?.registerMetricGroup('ipfs_bitswap_sent_blocks'),
-        dataSent: components.metrics?.registerMetricGroup('ipfs_bitswap_sent_data_bytes')
-      }
+    this.maxIncomingMessageSize = init.maxIncomingMessageSize ?? DEFAULT_MAX_OUTGOING_MESSAGE_SIZE
+    this.maxOutgoingMessageSize = init.maxOutgoingMessageSize ?? init.maxIncomingMessageSize ?? DEFAULT_MAX_INCOMING_MESSAGE_SIZE
+    this.metrics = {
+      blocksSent: components.libp2p.metrics?.registerCounter('helia_bitswap_sent_blocks_total'),
+      dataSent: components.libp2p.metrics?.registerCounter('helia_bitswap_sent_data_bytes_total')
     }
 
     this.sendQueue = new PeerQueue({
-      concurrency: init.messageSendConcurrency,
-      metrics: components.metrics,
-      metricName: 'ipfs_bitswap_message_send_queue'
+      concurrency: init.messageSendConcurrency ?? DEFAULT_MESSAGE_SEND_CONCURRENCY,
+      metrics: components.libp2p.metrics,
+      metricName: 'helia_bitswap_message_send_queue'
     })
     this.sendQueue.addEventListener('error', (evt) => {
       this.log.error('error sending wantlist to peer', evt.detail)
@@ -217,21 +185,29 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     Promise.resolve().then(async () => {
       this.log('incoming new bitswap %s stream from %p', stream.protocol, connection.remotePeer)
       const abortListener = (): void => {
-        stream.abort(new CodeError('Incoming Bitswap stream timed out', 'ERR_TIMEOUT'))
+        if (stream.status === 'open') {
+          stream.abort(new CodeError('Incoming Bitswap stream timed out', 'ERR_TIMEOUT'))
+        } else {
+          this.log('stream aborted with status', stream.status)
+        }
       }
 
       let signal = AbortSignal.timeout(this.messageReceiveTimeout)
       setMaxListeners(Infinity, signal)
       signal.addEventListener('abort', abortListener)
 
+      await stream.closeWrite()
+
       await pipe(
         stream,
-        (source) => lp.decode(source),
+        (source) => lp.decode(source, {
+          maxDataLength: this.maxIncomingMessageSize
+        }),
         async (source) => {
           for await (const data of source) {
             try {
               const message = BitswapMessage.decode(data)
-              this.log('incoming new bitswap %s message from %p %B', stream.protocol, connection.remotePeer, message)
+              this.log('incoming new bitswap %s message from %p on stream', stream.protocol, connection.remotePeer, stream.id)
 
               this.safeDispatchEvent('bitswap:message', {
                 detail: {
@@ -246,7 +222,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
               setMaxListeners(Infinity, signal)
               signal.addEventListener('abort', abortListener)
             } catch (err: any) {
-              this.log.error('error reading incoming bitswap message from %p', connection.remotePeer, err)
+              this.log.error('error reading incoming bitswap message from %p on stream', connection.remotePeer, stream.id, err)
               stream.abort(err)
               break
             }
@@ -267,29 +243,12 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:find-providers', cid))
 
     for await (const provider of this.routing.findProviders(cid, options)) {
-      // unless we explicitly run on transient connections, skip peers that only
-      // have circuit relay addresses as bitswap won't run over them
-      if (!this.runOnTransientConnections) {
-        let hasDirectAddress = false
-
-        for (let ma of provider.multiaddrs) {
-          if (ma.getPeerId() == null) {
-            ma = ma.encapsulate(`/p2p/${provider.id}`)
-          }
-
-          if (!Circuit.exactMatch(ma)) {
-            hasDirectAddress = true
-            break
-          }
-        }
-
-        if (!hasDirectAddress) {
-          continue
-        }
-      }
+      // make sure we can dial the provider
+      const dialable = await this.libp2p.isDialable(provider.multiaddrs, {
+        runOnTransientConnection: this.runOnTransientConnections
+      })
 
-      // ignore non-bitswap providers
-      if (provider.protocols?.includes('transport-bitswap') === false) {
+      if (!dialable) {
         continue
       }
 
@@ -302,9 +261,9 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
    */
   async findAndConnect (cid: CID, options?: WantOptions): Promise<void> {
     await drain(
-      take(
-        map(this.findProviders(cid, options), async provider => this.connectTo(provider.id, options)),
-        options?.maxProviders ?? DEFAULT_MAX_PROVIDERS_PER_REQUEST
+      map(
+        take(this.findProviders(cid, options), options?.maxProviders ?? DEFAULT_MAX_PROVIDERS_PER_REQUEST),
+        async provider => this.connectTo(provider.id, options)
       )
     )
       .catch(err => {
@@ -331,55 +290,55 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       pendingBytes: msg.pendingBytes ?? 0
     }
 
-    const signal = anySignal([AbortSignal.timeout(this.messageSendTimeout), options?.signal])
-    setMaxListeners(Infinity, signal)
+    const existingJob = this.sendQueue.queue.find(job => {
+      return peerId.equals(job.options.peerId) && job.status === 'queued'
+    })
 
-    try {
-      const existingJob = this.sendQueue.find(peerId)
+    if (existingJob != null) {
+      // merge messages instead of adding new job
+      existingJob.options.message = mergeMessages(existingJob.options.message, message)
 
-      if (existingJob?.status === 'queued') {
-        // merge messages instead of adding new job
-        existingJob.options.message = mergeMessages(existingJob.options.message, message)
+      await existingJob.join({
+        signal: options?.signal
+      })
 
-        await existingJob.join({
-          signal
-        })
+      return
+    }
 
-        return
-      }
+    await this.sendQueue.add(async (options) => {
+      const message = options?.message
 
-      await this.sendQueue.add(async (options) => {
-        const message = options?.message
+      if (message == null) {
+        throw new CodeError('No message to send', 'ERR_NO_MESSAGE')
+      }
 
-        if (message == null) {
-          throw new CodeError('No message to send', 'ERR_NO_MESSAGE')
-        }
+      this.log('sendMessage to %p', peerId)
 
-        this.log('sendMessage to %p %B', peerId, message)
+      options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:send-wantlist', peerId))
 
-        options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:send-wantlist', peerId))
+      const stream = await this.libp2p.dialProtocol(peerId, BITSWAP_120, options)
+      await stream.closeRead()
 
-        const stream = await this.libp2p.dialProtocol(peerId, BITSWAP_120, options)
+      try {
+        await pipe(
+          splitMessage(message, this.maxOutgoingMessageSize),
+          (source) => lp.encode(source),
+          stream
+        )
 
-        try {
-          const lp = lpStream(stream)
-          await lp.write(BitswapMessage.encode(message), options)
-          await lp.unwrap().close(options)
-        } catch (err: any) {
-          options?.onProgress?.(new CustomProgressEvent<{ peer: PeerId, error: Error }>('bitswap:network:send-wantlist:error', { peer: peerId, error: err }))
-          this.log.error('error sending message to %p', peerId, err)
-          stream.abort(err)
-        }
+        await stream.close(options)
+      } catch (err: any) {
+        options?.onProgress?.(new CustomProgressEvent<{ peer: PeerId, error: Error }>('bitswap:network:send-wantlist:error', { peer: peerId, error: err }))
+        this.log.error('error sending message to %p', peerId, err)
+        stream.abort(err)
+      }
 
-        this._updateSentStats(peerId, message.blocks)
-      }, {
-        peerId,
-        signal,
-        message
-      })
-    } finally {
-      signal.clear()
-    }
+      this._updateSentStats(message.blocks)
+    }, {
+      peerId,
+      signal: options?.signal,
+      message
+    })
   }
 
   /**
@@ -417,90 +376,14 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     return connection
   }
 
-  _updateSentStats (peerId: PeerId, blocks: Block[] = []): void {
-    if (this.metrics != null) {
-      let bytes = 0
-
-      for (const block of blocks.values()) {
-        bytes += block.data.byteLength
-      }
-
-      this.metrics.dataSent.increment({
-        global: bytes,
-        [peerId.toString()]: bytes
-      })
-      this.metrics.blocksSent.increment({
-        global: blocks.length,
-        [peerId.toString()]: blocks.length
-      })
-    }
-  }
-}
-
-function mergeMessages (messageA: BitswapMessage, messageB: BitswapMessage): BitswapMessage {
-  const wantListEntries = new Map<string, WantlistEntry>(
-    (messageA.wantlist?.entries ?? []).map(entry => ([
-      base64.encode(entry.cid),
-      entry
-    ]))
-  )
-
-  for (const entry of messageB.wantlist?.entries ?? []) {
-    const key = base64.encode(entry.cid)
-    const existingEntry = wantListEntries.get(key)
-
-    if (existingEntry != null) {
-      // take highest priority
-      if (existingEntry.priority > entry.priority) {
-        entry.priority = existingEntry.priority
-      }
+  _updateSentStats (blocks: Block[] = []): void {
+    let bytes = 0
 
-      // take later values if passed, otherwise use earlier ones
-      entry.cancel = entry.cancel ?? existingEntry.cancel
-      entry.wantType = entry.wantType ?? existingEntry.wantType
-      entry.sendDontHave = entry.sendDontHave ?? existingEntry.sendDontHave
+    for (const block of blocks.values()) {
+      bytes += block.data.byteLength
     }
 
-    wantListEntries.set(key, entry)
+    this.metrics.dataSent?.increment(bytes)
+    this.metrics.blocksSent?.increment(blocks.length)
   }
-
-  const blockPresences = new Map<string, BlockPresence>(
-    messageA.blockPresences.map(presence => ([
-      base64.encode(presence.cid),
-      presence
-    ]))
-  )
-
-  for (const blockPresence of messageB.blockPresences) {
-    const key = base64.encode(blockPresence.cid)
-
-    // override earlier block presence with later one as if duplicated it is
-    // likely to be more accurate since it is more recent
-    blockPresences.set(key, blockPresence)
-  }
-
-  const blocks = new Map<string, Block>(
-    messageA.blocks.map(block => ([
-      base64.encode(block.data),
-      block
-    ]))
-  )
-
-  for (const block of messageB.blocks) {
-    const key = base64.encode(block.data)
-
-    blocks.set(key, block)
-  }
-
-  const output: BitswapMessage = {
-    wantlist: {
-      full: messageA.wantlist?.full ?? messageB.wantlist?.full ?? false,
-      entries: [...wantListEntries.values()]
-    },
-    blockPresences: [...blockPresences.values()],
-    blocks: [...blocks.values()],
-    pendingBytes: messageA.pendingBytes + messageB.pendingBytes
-  }
-
-  return output
 }

package/src/pb/message.ts

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { type Codec, decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime'
+import { type Codec, CodeError, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -69,7 +69,7 @@ export namespace WantlistEntry {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           cid: uint8ArrayAlloc(0),
           priority: 0
@@ -119,8 +119,8 @@ export namespace WantlistEntry {
     return encodeMessage(obj, WantlistEntry.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): WantlistEntry => {
-    return decodeMessage(buf, WantlistEntry.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<WantlistEntry>): WantlistEntry => {
+    return decodeMessage(buf, WantlistEntry.codec(), opts)
   }
 }
 
@@ -154,7 +154,7 @@ export namespace Wantlist {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           entries: []
         }
@@ -166,7 +166,13 @@ export namespace Wantlist {
 
           switch (tag >>> 3) {
             case 1: {
-              obj.entries.push(WantlistEntry.codec().decode(reader, reader.uint32()))
+              if (opts.limits?.entries != null && obj.entries.length === opts.limits.entries) {
+                throw new CodeError('decode error - map field "entries" had too many elements', 'ERR_MAX_LENGTH')
+              }
+
+              obj.entries.push(WantlistEntry.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.entries$
+              }))
               break
             }
             case 2: {
@@ -191,8 +197,8 @@ export namespace Wantlist {
     return encodeMessage(obj, Wantlist.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Wantlist => {
-    return decodeMessage(buf, Wantlist.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Wantlist>): Wantlist => {
+    return decodeMessage(buf, Wantlist.codec(), opts)
   }
 }
 
@@ -224,7 +230,7 @@ export namespace Block {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           prefix: uint8ArrayAlloc(0),
           data: uint8ArrayAlloc(0)
@@ -262,8 +268,8 @@ export namespace Block {
     return encodeMessage(obj, Block.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Block => {
-    return decodeMessage(buf, Block.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Block>): Block => {
+    return decodeMessage(buf, Block.codec(), opts)
   }
 }
 
@@ -310,7 +316,7 @@ export namespace BlockPresence {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           cid: uint8ArrayAlloc(0),
           type: BlockPresenceType.HaveBlock
@@ -348,8 +354,8 @@ export namespace BlockPresence {
     return encodeMessage(obj, BlockPresence.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): BlockPresence => {
-    return decodeMessage(buf, BlockPresence.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<BlockPresence>): BlockPresence => {
+    return decodeMessage(buf, BlockPresence.codec(), opts)
   }
 }
 
@@ -397,7 +403,7 @@ export namespace BitswapMessage {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           blocks: [],
           blockPresences: [],
@@ -411,15 +417,29 @@ export namespace BitswapMessage {
 
           switch (tag >>> 3) {
             case 1: {
-              obj.wantlist = Wantlist.codec().decode(reader, reader.uint32())
+              obj.wantlist = Wantlist.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.wantlist
+              })
               break
             }
             case 3: {
-              obj.blocks.push(Block.codec().decode(reader, reader.uint32()))
+              if (opts.limits?.blocks != null && obj.blocks.length === opts.limits.blocks) {
+                throw new CodeError('decode error - map field "blocks" had too many elements', 'ERR_MAX_LENGTH')
+              }
+
+              obj.blocks.push(Block.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.blocks$
+              }))
               break
             }
             case 4: {
-              obj.blockPresences.push(BlockPresence.codec().decode(reader, reader.uint32()))
+              if (opts.limits?.blockPresences != null && obj.blockPresences.length === opts.limits.blockPresences) {
+                throw new CodeError('decode error - map field "blockPresences" had too many elements', 'ERR_MAX_LENGTH')
+              }
+
+              obj.blockPresences.push(BlockPresence.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.blockPresences$
+              }))
               break
             }
             case 5: {
@@ -444,7 +464,7 @@ export namespace BitswapMessage {
     return encodeMessage(obj, BitswapMessage.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): BitswapMessage => {
-    return decodeMessage(buf, BitswapMessage.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<BitswapMessage>): BitswapMessage => {
+    return decodeMessage(buf, BitswapMessage.codec(), opts)
   }
 }