@helia/bitswap 2.2.0 → 3.0.0

package/src/network.ts

@@ -1,9 +1,9 @@
 import { InvalidParametersError, NotStartedError, TimeoutError, TypedEventEmitter, UnsupportedProtocolError, setMaxListeners } from '@libp2p/interface'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { PeerQueue } from '@libp2p/utils'
 import drain from 'it-drain'
 import * as lp from 'it-length-prefixed'
 import map from 'it-map'
-import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
 import take from 'it-take'
 import { CustomProgressEvent } from 'progress-events'
 import { raceEvent } from 'race-event'
@@ -16,12 +16,13 @@ import type { MultihashHasherLoader } from './index.js'
 import type { Block } from './pb/message.js'
 import type { QueuedBitswapMessage } from './utils/bitswap-message.js'
 import type { Provider, Routing } from '@helia/interface/routing'
-import type { Libp2p, AbortOptions, Connection, PeerId, IncomingStreamData, Topology, ComponentLogger, IdentifyResult, Counter, Metrics } from '@libp2p/interface'
+import type { Libp2p, AbortOptions, Connection, PeerId, Topology, ComponentLogger, IdentifyResult, Counter, Metrics, Stream } from '@libp2p/interface'
 import type { Logger } from '@libp2p/logger'
-import type { PeerQueueJobOptions } from '@libp2p/utils/peer-queue'
+import type { PeerQueueJobOptions } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export type BitswapNetworkProgressEvents =
   ProgressEvent<'bitswap:network:dial', PeerId | Multiaddr | Multiaddr[]>
@@ -114,9 +115,6 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       metrics: components.metrics,
       metricName: 'helia_bitswap_message_send_queue'
     })
-    this.sendQueue.addEventListener('error', (evt) => {
-      this.log.error('error sending wantlist to peer', evt.detail)
-    })
   }
 
   async start (): Promise<void> {
@@ -179,13 +177,11 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
   /**
    * Handles incoming bitswap messages
    */
-  _onStream (info: IncomingStreamData): void {
+  _onStream (stream: Stream, connection: Connection): void {
     if (!this.running) {
       return
     }
 
-    const { stream, connection } = info
-
     Promise.resolve().then(async () => {
       this.log('incoming new bitswap %s stream from %p', stream.protocol, connection.remotePeer)
       const abortListener = (): void => {
@@ -200,39 +196,49 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       setMaxListeners(Infinity, signal)
       signal.addEventListener('abort', abortListener)
 
-      await stream.closeWrite()
-
-      await pipe(
-        stream,
-        (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 on stream', stream.protocol, connection.remotePeer, stream.id)
-
-              this.safeDispatchEvent('bitswap:message', {
-                detail: {
-                  peer: connection.remotePeer,
-                  message
-                }
-              })
-
-              // we have received some data so reset the timeout controller
-              signal.removeEventListener('abort', abortListener)
-              signal = AbortSignal.timeout(this.messageReceiveTimeout)
-              setMaxListeners(Infinity, signal)
-              signal.addEventListener('abort', abortListener)
-            } catch (err: any) {
-              this.log.error('error reading incoming bitswap message from %p on stream', connection.remotePeer, stream.id, err)
-              stream.abort(err)
-              break
+      await stream.close({
+        signal
+      })
+
+      const input = pushable<Uint8Array | Uint8ArrayList>()
+
+      stream.addEventListener('message', (evt) => {
+        input.push(evt.data)
+      })
+      stream.addEventListener('remoteCloseWrite', () => {
+        input.end()
+      })
+      stream.addEventListener('close', (evt) => {
+        if (evt.error != null) {
+          input.end(evt.error)
+        }
+      })
+
+      for await (const data of lp.decode(input, {
+        maxDataLength: this.maxIncomingMessageSize
+      })) {
+        try {
+          const message = BitswapMessage.decode(data)
+          this.log('incoming new bitswap %s message from %p on stream', stream.protocol, connection.remotePeer, stream.id)
+
+          this.safeDispatchEvent('bitswap:message', {
+            detail: {
+              peer: connection.remotePeer,
+              message
             }
-          }
+          })
+
+          // we have received some data so reset the timeout controller
+          signal.removeEventListener('abort', abortListener)
+          signal = AbortSignal.timeout(this.messageReceiveTimeout)
+          setMaxListeners(Infinity, signal)
+          signal.addEventListener('abort', abortListener)
+        } catch (err: any) {
+          this.log.error('error reading incoming bitswap message from %p on stream', connection.remotePeer, stream.id, err)
+          stream.abort(err)
+          break
         }
-      )
+      }
     })
       .catch(err => {
         this.log.error('error handling incoming stream from %p', connection.remotePeer, err)
@@ -324,11 +330,11 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       await stream.closeRead()
 
       try {
-        await pipe(
-          splitMessage(message, this.maxOutgoingMessageSize),
-          (source) => lp.encode(source),
-          stream
-        )
+        for (const buf of splitMessage(message, this.maxOutgoingMessageSize)) {
+          if (!stream.send(lp.encode.single(buf))) {
+            await stream.onDrain(options)
+          }
+        }
 
         await stream.close(options)
       } catch (err: any) {

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

@@ -1,3 +1,4 @@
+import toBuffer from 'it-to-buffer'
 import { DEFAULT_MAX_SIZE_REPLACE_HAS_WITH_BLOCK } from '../constants.js'
 import { BlockPresenceType, WantType } from '../pb/message.js'
 import { QueuedBitswapMessage } from '../utils/bitswap-message.js'
@@ -93,7 +94,7 @@ export class Ledger {
 
     for (const [key, entry] of this.wants.entries()) {
       try {
-        const block = await this.blockstore.get(entry.cid, options)
+        const block = await toBuffer(this.blockstore.get(entry.cid, options))
 
         // do they want the block or just us to tell them we have the block
         if (entry.wantType === WantType.WantHave) {

package/src/want-list.ts

@@ -1,6 +1,6 @@
 import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { trackedPeerMap } from '@libp2p/peer-collections'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { trackedMap } from '@libp2p/utils'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import pDefer from 'p-defer'