@helia/bitswap 3.2.3-f6cc7640 → 4.0.0

package/src/block-broker.ts

@@ -0,0 +1,119 @@
+import { isPeerId } from '@libp2p/interface'
+import { CustomProgressEvent } from 'progress-events'
+import { Bitswap } from './bitswap.ts'
+import type { BitswapOptions, BitswapWantBlockProgressEvents, BitswapNotifyProgressEvents } from './index.ts'
+import type { BlockAnnounceOptions, BlockBroker, BlockRetrievalOptions, CreateSessionOptions, Routing, HasherLoader, SessionBlockBroker, BlockBrokerConnectProgressEvent, BlockBrokerConnectedProgressEvent, BlockBrokerRequestBlockProgressEvent, BlockBrokerReceiveBlockProgressEvent } from '@helia/interface'
+import type { Libp2p, Startable, ComponentLogger } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
+import type { CID } from 'multiformats/cid'
+
+export interface BitswapBlockBrokerComponents {
+  libp2p: Libp2p
+  blockstore: Blockstore
+  routing: Routing
+  logger: ComponentLogger
+  getHasher: HasherLoader
+}
+
+export interface BitswapBlockBrokerInit extends BitswapOptions {
+
+}
+
+export class BitswapBlockBroker implements BlockBroker<BitswapWantBlockProgressEvents, BitswapNotifyProgressEvents>, Startable {
+  public readonly name = 'bitswap'
+  private readonly bitswap: Bitswap
+  private started: boolean
+
+  constructor (components: BitswapBlockBrokerComponents, init: BitswapBlockBrokerInit = {}) {
+    this.bitswap = new Bitswap(components, init)
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    await this.bitswap.start()
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await this.bitswap.stop()
+    this.started = false
+  }
+
+  async announce (cid: CID, options?: BlockAnnounceOptions<BitswapNotifyProgressEvents>): Promise<void> {
+    await this.bitswap.notify(cid, options)
+  }
+
+  async retrieve (cid: CID, options: BlockRetrievalOptions<BitswapWantBlockProgressEvents> = {}): Promise<Uint8Array> {
+    return this.bitswap.want(cid, {
+      ...options,
+      onProgress: function bitswapBlockBrokerRetrieveCallback (evt) {
+        if (options?.onProgress == null) {
+          return
+        }
+
+        options.onProgress(evt)
+
+        if (evt.type === 'connection:open') {
+          if (!isPeerId(evt.detail)) {
+            // should not happen as bitswap impl only sends wantlist to
+            // connected peers so we always have a peer id
+            return
+          }
+
+          options.onProgress(new CustomProgressEvent<BlockBrokerConnectProgressEvent>('helia:block-broker:connect', {
+            broker: 'bitswap',
+            type: 'connect',
+            provider: evt.detail.toCID(),
+            cid
+          }))
+        } else if (evt.type === 'connection:opened') {
+          options.onProgress(new CustomProgressEvent<BlockBrokerConnectedProgressEvent>('helia:block-broker:connected', {
+            broker: 'bitswap',
+            type: 'connected',
+            provider: evt.detail.remotePeer.toCID(),
+            address: evt.detail.remoteAddr,
+            cid
+          }))
+        } else if (evt.type === 'bitswap:send-wantlist') {
+          options.onProgress(new CustomProgressEvent<BlockBrokerRequestBlockProgressEvent>('helia:block-broker:request-block', {
+            broker: 'bitswap',
+            type: 'request-block',
+            provider: evt.detail.toCID(),
+            cid
+          }))
+        } else if (evt.type === 'bitswap:block') {
+          options.onProgress(new CustomProgressEvent<BlockBrokerReceiveBlockProgressEvent>('helia:block-broker:receive-block', {
+            broker: 'bitswap',
+            type: 'receive-block',
+            provider: evt.detail.sender.toCID(),
+            cid
+          }))
+        }
+      }
+    })
+  }
+
+  createSession (options?: CreateSessionOptions<BitswapWantBlockProgressEvents>): SessionBlockBroker<BitswapWantBlockProgressEvents, BitswapNotifyProgressEvents> {
+    const session = this.bitswap.createSession(options)
+
+    return {
+      name: 'bitswap-session',
+
+      addPeer: async (peer, options) => {
+        await session.addPeer(peer, options)
+      },
+
+      announce: async (cid, options) => {
+        await this.bitswap.notify(cid, options)
+      },
+
+      retrieve: async (cid, options) => {
+        return session.retrieve(cid, options)
+      }
+    }
+  }
+}

package/src/index.ts

@@ -6,11 +6,14 @@
  * It supersedes the older [ipfs-bitswap](https://www.npmjs.com/package/ipfs-bitswap) module with the aim of being smaller, faster, better integrated with libp2p/helia, having fewer dependencies and using standard JavaScript instead of Node.js APIs.
  */
 
-import { Bitswap as BitswapClass } from './bitswap.ts'
+import { start } from '@libp2p/interface'
+import { BitswapBlockBroker } from './block-broker.ts'
+import type { BitswapBlockBrokerInit } from './block-broker.ts'
 import type { BitswapNetworkNotifyProgressEvents, BitswapNetworkWantProgressEvents, BitswapNetworkProgressEvents } from './network.ts'
 import type { WantType } from './pb/message.ts'
-import type { BlockBrokerGetBlockProgressEvents, CreateSessionOptions, HasherLoader, ProviderOptions, SessionBlockBroker } from '@helia/interface'
-import type { Routing } from '@helia/interface/routing'
+import type { BlockBrokerGetBlockProgressEvents, CreateSessionOptions, HasherLoader, HeliaMixin, ProviderOptions, SessionBlockBroker } from '@helia/interface'
+import type { Routing } from '@helia/interface'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { Libp2p, AbortOptions, Startable, ComponentLogger, Metrics, PeerId } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { CID } from 'multiformats/cid'
@@ -34,6 +37,7 @@ export type { BitswapNetworkWantProgressEvents }
 export type { BitswapNetworkProgressEvents }
 export type { WantType }
 export type { BitswapProvider } from './network.ts'
+export type { BitswapBlockBrokerInit } from './block-broker.ts'
 
 export type WantStatus = 'want' | 'sending' | 'sent'
 
@@ -227,6 +231,23 @@ export interface BitswapOptions {
   maxWantlistSize?: number
 }
 
-export const createBitswap = (components: BitswapComponents, options: BitswapOptions = {}): Bitswap => {
-  return new BitswapClass(components, options)
+/**
+ * Return a Helia node augmented with a libp2p instance
+ */
+export function withBitswap (helia: HeliaWithLibp2p, options: BitswapBlockBrokerInit = {}): HeliaWithLibp2p {
+  const mixin: HeliaMixin<HeliaWithLibp2p> = {
+    name: 'bitswap',
+    start: async (helia) => {
+      if (helia.status === 'starting' && !helia.hasBlockBroker('bitswap')) {
+        const broker = new BitswapBlockBroker(helia, options)
+        await start(broker)
+
+        helia.addBlockBroker(broker)
+      }
+    }
+  }
+
+  helia.addMixin(mixin)
+
+  return helia
 }

package/src/network.ts

@@ -1,5 +1,8 @@
-import { InvalidParametersError, NotStartedError, TimeoutError, TypedEventEmitter, UnsupportedProtocolError, setMaxListeners } from '@libp2p/interface'
+import { isCID } from '@helia/utils'
+import { InvalidParametersError, NotStartedError, TimeoutError, TypedEventEmitter, isPeerId, setMaxListeners } from '@libp2p/interface'
+import { peerIdFromCID } from '@libp2p/peer-id'
 import { PeerQueue } from '@libp2p/utils'
+import { isMultiaddr } from '@multiformats/multiaddr'
 import drain from 'it-drain'
 import * as lp from 'it-length-prefixed'
 import map from 'it-map'
@@ -7,7 +10,6 @@ import { pushable } from 'it-pushable'
 import take from 'it-take'
 import { CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
-import { raceEvent } from 'race-event'
 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_MESSAGE_SEND_TIMEOUT, DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS } from './constants.ts'
 import { BitswapMessage } from './pb/message.ts'
 import { mergeMessages } from './utils/merge-messages.ts'
@@ -16,8 +18,8 @@ import type { WantOptions } from './bitswap.ts'
 import type { Block } from './pb/message.ts'
 import type { QueuedBitswapMessage } from './utils/bitswap-message.ts'
 import type { BlockBrokerGetBlockProgressEvents } from '@helia/interface'
-import type { Provider, Routing, RoutingFindProvidersProgressEvents } from '@helia/interface/routing'
-import type { Libp2p, AbortOptions, Connection, PeerId, Topology, ComponentLogger, IdentifyResult, Counter, Metrics, Stream, OpenConnectionProgressEvents, NewStreamProgressEvents } from '@libp2p/interface'
+import type { Provider, Routing, RoutingFindProvidersProgressEvents } from '@helia/interface'
+import type { Libp2p, AbortOptions, Connection, PeerId, Topology, ComponentLogger, Counter, Metrics, Stream, OpenConnectionProgressEvents, NewStreamProgressEvents } from '@libp2p/interface'
 import type { Logger } from '@libp2p/logger'
 import type { PeerQueueJobOptions } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -102,6 +104,22 @@ interface SendMessageJobOptions extends AbortOptions, ProgressOptions<BitswapNet
   message: QueuedBitswapMessage
 }
 
+function toDialable (peer: CID | PeerId | Multiaddr | Multiaddr[]): PeerId | Multiaddr | Multiaddr[] {
+  if (isPeerId(peer)) {
+    return peer
+  }
+
+  if (isCID(peer)) {
+    return peerIdFromCID(peer)
+  }
+
+  if (isMultiaddr(peer) || Array.isArray(peer)) {
+    return peer
+  }
+
+  throw new InvalidParametersError(`Peer ${peer} was not a CID, a Multiaddr or a Multiaddr[]`)
+}
+
 export class Network extends TypedEventEmitter<NetworkEvents> {
   private readonly log: Logger
   private readonly libp2p: Libp2p
@@ -236,7 +254,6 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
       const input = pushable<Uint8Array | Uint8ArrayList>()
 
       stream.addEventListener('message', (evt) => {
-        // @ts-expect-error libp2p needs dep updates
         input.push(evt.data)
       })
       stream.addEventListener('remoteCloseWrite', () => {
@@ -316,7 +333,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
     // connect to initial session providers if supplied
     if (options?.providers != null) {
       await Promise.all(
-        options.providers.map(async prov => this.connectTo(prov)
+        options.providers.map(async prov => this.connectTo(prov, options)
           .catch(err => {
             this.log.error('could not connect to supplied provider - %e', err)
           }))
@@ -371,7 +388,6 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
 
       try {
         for (const buf of splitMessage(message, this.maxOutgoingMessageSize)) {
-          // @ts-expect-error libp2p needs dep updates
           if (!stream.send(lp.encode.single(buf))) {
             await stream.onDrain(options)
           }
@@ -399,36 +415,16 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
   /**
    * Connects to another peer
    */
-  async connectTo (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions & ProgressOptions<BitswapNetworkProgressEvents>): Promise<Connection> {
+  async connectTo (peer: CID | PeerId | Multiaddr | Multiaddr[], options?: AbortOptions & ProgressOptions<BitswapNetworkProgressEvents>): Promise<Connection> {
     if (!this.running) {
       throw new NotStartedError('Network isn\'t running')
     }
 
-    options?.onProgress?.(new CustomProgressEvent<PeerId | Multiaddr | Multiaddr[]>('bitswap:dial', peer))
-
-    // dial and wait for identify - this is to avoid opening a protocol stream
-    // that we are not going to use but depends on the remote node running the
-    // identify protocol
-    const [
-      connection
-    ] = await Promise.all([
-      this.libp2p.dial(peer, options),
-      raceEvent(this.libp2p, 'peer:identify', options?.signal, {
-        filter: (evt: CustomEvent<IdentifyResult>): boolean => {
-          if (!evt.detail.peerId.equals(peer)) {
-            return false
-          }
-
-          if (evt.detail.protocols.includes(BITSWAP_120)) {
-            return true
-          }
+    peer = toDialable(peer)
 
-          throw new UnsupportedProtocolError(`${peer} did not support ${BITSWAP_120}`)
-        }
-      })
-    ])
+    options?.onProgress?.(new CustomProgressEvent<PeerId | Multiaddr | Multiaddr[]>('bitswap:dial', peer))
 
-    return connection
+    return this.libp2p.dial(peer, options)
   }
 
   _updateSentStats (blocks: Map<string, Block>): void {

package/src/session.ts

@@ -1,13 +1,13 @@
-import { AbstractSession } from '@helia/utils'
-import { isPeerId } from '@libp2p/interface'
+import { AbstractSession, isCID } from '@helia/utils'
+import { peerIdFromCID } from '@libp2p/peer-id'
+import { CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
 import type { BitswapProvider, BitswapWantProgressEvents } from './index.ts'
 import type { Network } from './network.ts'
 import type { WantList } from './want-list.ts'
 import type { BlockRetrievalOptions, CreateSessionOptions } from '@helia/interface'
-import type { ComponentLogger, Libp2p, PeerId, AbortOptions } from '@libp2p/interface'
+import type { ComponentLogger, Libp2p, AbortOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { CID } from 'multiformats/cid'
 
 export interface BitswapSessionComponents {
   network: Network
@@ -17,7 +17,7 @@ export interface BitswapSessionComponents {
 }
 
 interface ProviderPeer {
-  peerId: PeerId
+  peerId: CID
   routing: string
   toString(): string
 }
@@ -40,9 +40,11 @@ class BitswapSession extends AbstractSession<ProviderPeer, BitswapWantProgressEv
   }
 
   async queryProvider (cid: CID, provider: ProviderPeer, options: AbortOptions): Promise<Uint8Array> {
-    this.log('sending WANT-BLOCK for %c to %p', cid, provider)
+    const peerId = peerIdFromCID(provider.peerId)
 
-    const result = await this.wantList.wantSessionBlock(cid, provider.peerId, options)
+    this.log('sending WANT-BLOCK for %c to %p', cid, peerId)
+
+    const result = await this.wantList.wantSessionBlock(cid, peerId, options)
 
     this.log('%p %s %c', provider, result.has ? 'has' : 'does not have', cid)
 
@@ -68,15 +70,15 @@ class BitswapSession extends AbstractSession<ProviderPeer, BitswapWantProgressEv
   }
 
   toFilterKey (provider: ProviderPeer): Uint8Array | string {
-    return provider.peerId.toMultihash().bytes
+    return provider.peerId.multihash.bytes
   }
 
   equals (providerA: ProviderPeer, providerB: ProviderPeer): boolean {
     return providerA.peerId.equals(providerB.peerId)
   }
 
-  async convertToProvider (provider: PeerId | Multiaddr | Multiaddr[], routing: string, options?: AbortOptions): Promise<ProviderPeer | undefined> {
-    if (isPeerId(provider)) {
+  async convertToProvider (provider: CID | Multiaddr | Multiaddr[], routing: string, options?: AbortOptions): Promise<ProviderPeer | undefined> {
+    if (isCID(provider)) {
       return {
         peerId: provider,
         routing,
@@ -92,7 +94,7 @@ class BitswapSession extends AbstractSession<ProviderPeer, BitswapWantProgressEv
       const connection = await this.libp2p.dial(provider, options)
 
       return {
-        peerId: connection.remotePeer,
+        peerId: connection.remotePeer.toCID(),
         routing,
         toString: () => `Bitswap(${connection.remotePeer})`
       }