@helia/bitswap 1.0.0 → 1.0.1-0a528bb

package/src/index.ts

@@ -117,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
    *
@@ -167,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,55 +1,25 @@
 import { CodeError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { PeerQueue, type PeerQueueJobOptions } from '@libp2p/utils/peer-queue'
-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_CONCURRENCY, 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, ComponentLogger, IdentifyResult, Counter } from '@libp2p/interface'
+import type { Libp2p, AbortOptions, Connection, PeerId, IncomingStreamData, Topology, ComponentLogger, IdentifyResult, Counter, Metrics } 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>
 
@@ -68,16 +38,18 @@ 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,8 +79,9 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
   private registrarIds: string[]
   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()
@@ -125,16 +98,17 @@ 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
+    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')
+      blocksSent: components.metrics?.registerCounter('helia_bitswap_sent_blocks_total'),
+      dataSent: components.metrics?.registerCounter('helia_bitswap_sent_data_bytes_total')
     }
 
     this.sendQueue = new PeerQueue({
       concurrency: init.messageSendConcurrency ?? DEFAULT_MESSAGE_SEND_CONCURRENCY,
-      metrics: components.libp2p.metrics,
+      metrics: components.metrics,
       metricName: 'helia_bitswap_message_send_queue'
     })
     this.sendQueue.addEventListener('error', (evt) => {
@@ -212,21 +186,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: {
@@ -241,7 +223,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
             }
@@ -309,58 +291,55 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       pendingBytes: msg.pendingBytes ?? 0
     }
 
-    const timeoutSignal = AbortSignal.timeout(this.messageSendTimeout)
-    const signal = anySignal([timeoutSignal, options?.signal])
-    setMaxListeners(Infinity, timeoutSignal, signal)
+    const existingJob = this.sendQueue.queue.find(job => {
+      return peerId.equals(job.options.peerId) && job.status === 'queued'
+    })
 
-    try {
-      const existingJob = this.sendQueue.queue.find(job => {
-        return peerId.equals(job.options.peerId) && job.status === 'queued'
+    if (existingJob != null) {
+      // merge messages instead of adding new job
+      existingJob.options.message = mergeMessages(existingJob.options.message, message)
+
+      await existingJob.join({
+        signal: options?.signal
       })
 
-      if (existingJob != null) {
-        // merge messages instead of adding new job
-        existingJob.options.message = mergeMessages(existingJob.options.message, message)
+      return
+    }
 
-        await existingJob.join({
-          signal
-        })
+    await this.sendQueue.add(async (options) => {
+      const message = options?.message
 
-        return
+      if (message == null) {
+        throw new CodeError('No message to send', 'ERR_NO_MESSAGE')
       }
 
-      await this.sendQueue.add(async (options) => {
-        const message = options?.message
+      this.log('sendMessage to %p', peerId)
 
-        if (message == null) {
-          throw new CodeError('No message to send', 'ERR_NO_MESSAGE')
-        }
+      options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:send-wantlist', peerId))
 
-        this.log('sendMessage to %p %B', peerId, message)
+      const stream = await this.libp2p.dialProtocol(peerId, BITSWAP_120, options)
+      await stream.closeRead()
 
-        options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:send-wantlist', peerId))
+      try {
+        await pipe(
+          splitMessage(message, this.maxOutgoingMessageSize),
+          (source) => lp.encode(source),
+          stream
+        )
 
-        const stream = await this.libp2p.dialProtocol(peerId, BITSWAP_120, options)
-
-        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(message.blocks)
-      }, {
-        peerId,
-        signal,
-        message
-      })
-    } finally {
-      signal.clear()
-    }
+      this._updateSentStats(message.blocks)
+    }, {
+      peerId,
+      signal: options?.signal,
+      message
+    })
   }
 
   /**
@@ -409,71 +388,3 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     this.metrics.blocksSent?.increment(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
-      }
-
-      // 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
-    }
-
-    wantListEntries.set(key, entry)
-  }
-
-  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)
   }
 }

package/src/peer-want-lists/index.ts

@@ -6,7 +6,7 @@ import { Ledger } from './ledger.js'
 import type { BitswapNotifyProgressEvents, WantListEntry } from '../index.js'
 import type { Network } from '../network.js'
 import type { BitswapMessage } from '../pb/message.js'
-import type { ComponentLogger, Libp2p, Logger, PeerId } from '@libp2p/interface'
+import type { ComponentLogger, Libp2p, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Blockstore } from 'interface-blockstore'
 import type { AbortOptions } from 'it-length-prefixed-stream'
@@ -21,6 +21,7 @@ export interface PeerWantListsComponents {
   network: Network
   libp2p: Libp2p
   logger: ComponentLogger
+  metrics?: Metrics
 }
 
 export interface PeerLedger {
@@ -37,16 +38,18 @@ export class PeerWantLists {
   public readonly ledgerMap: PeerMap<Ledger>
   private readonly maxSizeReplaceHasWithBlock?: number
   private readonly log: Logger
+  private readonly logger: ComponentLogger
 
   constructor (components: PeerWantListsComponents, init: PeerWantListsInit = {}) {
     this.blockstore = components.blockstore
     this.network = components.network
     this.maxSizeReplaceHasWithBlock = init.maxSizeReplaceHasWithBlock
     this.log = components.logger.forComponent('helia:bitswap:peer-want-lists')
+    this.logger = components.logger
 
     this.ledgerMap = trackedPeerMap({
       name: 'helia_bitswap_ledger_map',
-      metrics: components.libp2p.metrics
+      metrics: components.metrics
     })
 
     this.network.addEventListener('bitswap:message', (evt) => {
@@ -100,7 +103,8 @@ export class PeerWantLists {
       ledger = new Ledger({
         peerId,
         blockstore: this.blockstore,
-        network: this.network
+        network: this.network,
+        logger: this.logger
       }, {
         maxSizeReplaceHasWithBlock: this.maxSizeReplaceHasWithBlock
       })
@@ -141,6 +145,7 @@ export class PeerWantLists {
       }
     }
 
+    this.log('send blocks to peer')
     await ledger.sendBlocksToPeer()
   }
 

package/src/peer-want-lists/ledger.ts

@@ -3,7 +3,7 @@ import { DEFAULT_MAX_SIZE_REPLACE_HAS_WITH_BLOCK } from '../constants.js'
 import { BlockPresenceType, type BitswapMessage, WantType } from '../pb/message.js'
 import { cidToPrefix } from '../utils/cid-prefix.js'
 import type { Network } from '../network.js'
-import type { PeerId } from '@libp2p/interface'
+import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { AbortOptions } from 'it-length-prefixed-stream'
 import type { CID } from 'multiformats/cid'
@@ -12,6 +12,7 @@ export interface LedgerComponents {
   peerId: PeerId
   blockstore: Blockstore
   network: Network
+  logger: ComponentLogger
 }
 
 export interface LedgerInit {
@@ -56,12 +57,14 @@ export class Ledger {
   public bytesReceived: number
   public lastExchange?: number
   private readonly maxSizeReplaceHasWithBlock: number
+  private readonly log: Logger
 
   constructor (components: LedgerComponents, init: LedgerInit) {
     this.peerId = components.peerId
     this.blockstore = components.blockstore
     this.network = components.network
     this.wants = new Map()
+    this.log = components.logger.forComponent(`helia:bitswap:ledger:${components.peerId}`)
 
     this.exchangeCount = 0
     this.bytesSent = 0
@@ -96,6 +99,8 @@ export class Ledger {
       const has = await this.blockstore.has(entry.cid, options)
 
       if (!has) {
+        this.log('do not have block for %c', entry.cid)
+
         // we don't have the requested block and the remote is not interested
         // in us telling them that
         if (!entry.sendDontHave) {
@@ -121,6 +126,7 @@ export class Ledger {
       // do they want the block or just us to tell them we have the block
       if (entry.wantType === WantType.WantHave) {
         if (block.byteLength < this.maxSizeReplaceHasWithBlock) {
+          this.log('sending have and block for %c', entry.cid)
           // if the block is small we just send it to them
           sentBlocks.add(key)
           message.blocks.push({
@@ -128,6 +134,7 @@ export class Ledger {
             prefix: cidToPrefix(entry.cid)
           })
         } else {
+          this.log('sending have for %c', entry.cid)
           // otherwise tell them we have the block
           message.blockPresences.push({
             cid: entry.cid.bytes,
@@ -135,6 +142,7 @@ export class Ledger {
           })
         }
       } else {
+        this.log('sending block for %c', entry.cid)
         // they want the block, send it to them
         sentBlocks.add(key)
         message.blocks.push({
@@ -146,7 +154,9 @@ export class Ledger {
 
     // only send the message if we actually have something to send
     if (message.blocks.length > 0 || message.blockPresences.length > 0) {
+      this.log('sending message')
       await this.network.sendMessage(this.peerId, message, options)
+      this.log('sent message')
 
       // update accounting
       this.sentBytes(message.blocks.reduce((acc, curr) => acc + curr.data.byteLength, 0))

package/src/stats.ts

@@ -1,7 +1,8 @@
-import type { Libp2p, MetricGroup, PeerId } from '@libp2p/interface'
+import type { Libp2p, MetricGroup, Metrics, PeerId } from '@libp2p/interface'
 
 export interface StatsComponents {
   libp2p: Libp2p
+  metrics?: Metrics
 }
 
 export class Stats {
@@ -11,10 +12,10 @@ export class Stats {
   private readonly duplicateDataReceived?: MetricGroup
 
   constructor (components: StatsComponents) {
-    this.blocksReceived = components.libp2p.metrics?.registerMetricGroup('helia_bitswap_received_blocks')
-    this.duplicateBlocksReceived = components.libp2p.metrics?.registerMetricGroup('helia_bitswap_duplicate_received_blocks')
-    this.dataReceived = components.libp2p.metrics?.registerMetricGroup('helia_bitswap_data_received_bytes')
-    this.duplicateDataReceived = components.libp2p.metrics?.registerMetricGroup('helia_bitswap_duplicate_data_received_bytes')
+    this.blocksReceived = components.metrics?.registerMetricGroup('helia_bitswap_received_blocks')
+    this.duplicateBlocksReceived = components.metrics?.registerMetricGroup('helia_bitswap_duplicate_received_blocks')
+    this.dataReceived = components.metrics?.registerMetricGroup('helia_bitswap_data_received_bytes')
+    this.duplicateDataReceived = components.metrics?.registerMetricGroup('helia_bitswap_duplicate_data_received_bytes')
   }
 
   updateBlocksReceived (count: number = 1, peerId?: PeerId): void {