@helia/bitswap 2.0.5-daaa511 → 2.1.0-d43efc7

package/src/network.ts

@@ -1,5 +1,5 @@
 import { InvalidParametersError, NotStartedError, TimeoutError, TypedEventEmitter, UnsupportedProtocolError, setMaxListeners } from '@libp2p/interface'
-import { PeerQueue, type PeerQueueJobOptions } from '@libp2p/utils/peer-queue'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
 import drain from 'it-drain'
 import * as lp from 'it-length-prefixed'
 import map from 'it-map'
@@ -18,11 +18,13 @@ 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 { Logger } from '@libp2p/logger'
+import type { PeerQueueJobOptions } from '@libp2p/utils/peer-queue'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
 export type BitswapNetworkProgressEvents =
-  ProgressEvent<'bitswap:network:dial', PeerId>
+  ProgressEvent<'bitswap:network:dial', PeerId | Multiaddr | Multiaddr[]>
 
 export type BitswapNetworkWantProgressEvents =
   ProgressEvent<'bitswap:network:send-wantlist', PeerId> |
@@ -262,6 +264,17 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
    * Find the providers of a given `cid` and connect to them.
    */
   async findAndConnect (cid: CID, options?: WantOptions): Promise<void> {
+    // connect to initial session providers if supplied
+    if (options?.providers != null) {
+      await Promise.all(
+        options.providers.map(async prov => this.connectTo(prov)
+          .catch(err => {
+            this.log.error('could not connect to supplied provider - %e', err)
+          }))
+      )
+    }
+
+    // make a routing query to find additional providers
     await drain(
       map(
         take(this.findProviders(cid, options), options?.maxProviders ?? DEFAULT_MAX_PROVIDERS_PER_REQUEST),
@@ -335,12 +348,12 @@ export class Network extends TypedEventEmitter<NetworkEvents> {
   /**
    * Connects to another peer
    */
-  async connectTo (peer: PeerId, options?: AbortOptions & ProgressOptions<BitswapNetworkProgressEvents>): Promise<Connection> { // eslint-disable-line require-await
+  async connectTo (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions & ProgressOptions<BitswapNetworkProgressEvents>): Promise<Connection> { // eslint-disable-line require-await
     if (!this.running) {
       throw new NotStartedError('Network isn\'t running')
     }
 
-    options?.onProgress?.(new CustomProgressEvent<PeerId>('bitswap:network:dial', peer))
+    options?.onProgress?.(new CustomProgressEvent<PeerId | Multiaddr | Multiaddr[]>('bitswap:network: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

package/src/pb/message.ts

@@ -4,8 +4,9 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, MaxLengthError, message } from 'protons-runtime'
+import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
+import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export enum WantType {

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

@@ -6,10 +6,9 @@ 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, Metrics, PeerId } from '@libp2p/interface'
+import type { AbortOptions, 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'
 import type { ProgressOptions } from 'progress-events'
 
 export interface PeerWantListsInit {

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

@@ -4,9 +4,8 @@ import { BlockPresenceType, WantType } from '../pb/message.js'
 import { QueuedBitswapMessage } from '../utils/bitswap-message.js'
 import { cidToPrefix } from '../utils/cid-prefix.js'
 import type { Network } from '../network.js'
-import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
+import type { AbortOptions, 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'
 
 export interface LedgerComponents {

package/src/session.ts

@@ -1,9 +1,11 @@
 import { AbstractSession } from '@helia/utils'
+import { isPeerId } from '@libp2p/interface'
 import type { BitswapWantProgressEvents } from './index.js'
 import type { Network } from './network.js'
 import type { WantList } from './want-list.js'
 import type { CreateSessionOptions } from '@helia/interface'
-import type { ComponentLogger, PeerId } from '@libp2p/interface'
+import type { ComponentLogger, Libp2p, PeerId } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { AbortOptions } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 
@@ -11,11 +13,13 @@ export interface BitswapSessionComponents {
   network: Network
   wantList: WantList
   logger: ComponentLogger
+  libp2p: Libp2p
 }
 
 class BitswapSession extends AbstractSession<PeerId, BitswapWantProgressEvents> {
   private readonly wantList: WantList
   private readonly network: Network
+  private readonly libp2p: Libp2p
 
   constructor (components: BitswapSessionComponents, init: CreateSessionOptions) {
     super(components, {
@@ -25,6 +29,7 @@ class BitswapSession extends AbstractSession<PeerId, BitswapWantProgressEvents>
 
     this.wantList = components.wantList
     this.network = components.network
+    this.libp2p = components.libp2p
   }
 
   async queryProvider (cid: CID, provider: PeerId, options: AbortOptions): Promise<Uint8Array> {
@@ -54,6 +59,16 @@ class BitswapSession extends AbstractSession<PeerId, BitswapWantProgressEvents>
   equals (providerA: PeerId, providerB: PeerId): boolean {
     return providerA.equals(providerB)
   }
+
+  async convertToProvider (provider: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<PeerId | undefined> {
+    if (isPeerId(provider)) {
+      return provider
+    }
+
+    const connection = await this.libp2p.dial(provider, options)
+
+    return connection.remotePeer
+  }
 }
 
 export function createBitswapSession (components: BitswapSessionComponents, init: CreateSessionOptions): BitswapSession {