feat: support p2p retrieval by default

packages/verified-fetch/package.json

@@ -144,6 +144,7 @@
   "dependencies": {
     "@helia/block-brokers": "^4.0.0",
     "@helia/car": "^4.0.0",
+    "@helia/delegated-routing-v1-http-api-client": "^4.1.2",
     "@helia/http": "^2.0.0",
     "@helia/interface": "^5.0.0",
     "@helia/ipns": "^8.0.0",
@@ -155,16 +156,21 @@
     "@libp2p/interface": "^2.1.3",
     "@libp2p/kad-dht": "^14.0.1",
     "@libp2p/peer-id": "^5.0.5",
+    "@libp2p/webrtc": "^5.0.16",
+    "@libp2p/websockets": "^9.0.11",
+    "@libp2p/webtransport": "^5.0.16",
     "@multiformats/dns": "^1.0.6",
     "cborg": "^4.2.4",
     "hashlru": "^2.3.0",
+    "helia": "^5.1.0",
     "interface-blockstore": "^5.3.1",
     "interface-datastore": "^8.3.1",
     "ipfs-unixfs-exporter": "^13.6.1",
     "it-map": "^3.1.1",
     "it-pipe": "^3.0.1",
     "it-tar": "^6.0.5",
     "it-to-browser-readablestream": "^2.0.9",
+    "libp2p": "^2.2.1",
     "lru-cache": "^10.2.2",
     "multiformats": "^13.3.0",
     "progress-events": "^1.0.1",
@@ -185,7 +191,6 @@
     "blockstore-core": "^5.0.2",
     "browser-readablestream-to-it": "^2.0.7",
     "datastore-core": "^10.0.2",
-    "helia": "^5.0.0",
     "ipfs-unixfs-importer": "^15.3.1",
     "ipns": "^10.0.0",
     "it-all": "^3.0.6",

packages/verified-fetch/src/index.ts

@@ -594,10 +594,16 @@
  * 4. `AbortError` - If the content request is aborted due to user aborting provided AbortSignal. Note that this is a `AbortError` from `@libp2p/interface` and not the standard `AbortError` from the Fetch API.
  */
 
-import { trustlessGateway } from '@helia/block-brokers'
+import { bitswap, trustlessGateway } from '@helia/block-brokers'
+import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
 import { createHeliaHTTP } from '@helia/http'
-import { delegatedHTTPRouting, httpGatewayRouting } from '@helia/routers'
+import { delegatedHTTPRouting, httpGatewayRouting, libp2pRouting } from '@helia/routers'
+import { webRTCDirect } from '@libp2p/webrtc'
+import { webSockets } from '@libp2p/websockets'
+import { webTransport } from '@libp2p/webtransport'
 import { dns } from '@multiformats/dns'
+import { createHelia, libp2pDefaults } from 'helia'
+import { createLibp2p } from 'libp2p'
 import { VerifiedFetch as VerifiedFetchClass } from './verified-fetch.js'
 import type { GetBlockProgressEvents, Helia } from '@helia/interface'
 import type { ResolveDNSLinkProgressEvents } from '@helia/ipns'
@@ -639,6 +645,27 @@
   gateways: string[]
   routers?: string[]
 
+  /**
+   * Whether to enable WebTransport providers.
+   *
+   * @default false
+   */
+  webSockets?: boolean
+
+  /**
+   * Whether to enable WebTransport providers.
+   *
+   * @default false
+   */
+  webTransport?: boolean
+
+  /**
+   * Whether to enable WebRTC providers.
+   *
+   * @default false
+   */
+  webRTC?: boolean
+
   /**
    * In order to parse DNSLink records, we need to resolve DNS queries. You can
    * pass a list of DNS resolvers that we will provide to the @helia/ipns
@@ -789,21 +816,67 @@
  */
 export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchInit, options?: CreateVerifiedFetchOptions): Promise<VerifiedFetch> {
   if (!isHelia(init)) {
-    init = await createHeliaHTTP({
-      blockBrokers: [
-        trustlessGateway({
-          allowInsecure: init?.allowInsecure,
-          allowLocal: init?.allowLocal
-        })
-      ],
-      routers: [
-        ...(init?.routers ?? ['https://delegated-ipfs.dev']).map((routerUrl) => delegatedHTTPRouting(routerUrl)),
-        httpGatewayRouting({
-          gateways: init?.gateways ?? ['https://trustless-gateway.link']
-        })
-      ],
-      dns: createDns(init?.dnsResolvers)
-    })
+    if (init?.webTransport ?? init?.webSockets ?? init?.webRTC ?? false) {
+      const libp2pConfig = libp2pDefaults()
+
+      libp2pConfig.transports = []
+
+      if (init?.webTransport === true) {
+        libp2pConfig.transports.push(webTransport())
+      }
+      if (init?.webSockets === true) {
+        libp2pConfig.transports.push(webSockets())
+      }
+      if (init?.webRTC === true) {
+        libp2pConfig.transports.push(webRTCDirect())
+      }
+
+      libp2pConfig.peerDiscovery = [] // disable default bootstrap peers
+      libp2pConfig.addresses = {} // disable default listen addresses
+
+      const routers = init?.routers ?? ['https://delegated-ipfs.dev']
+      for (let index = 0; index < routers.length; index++) {
+        const routerUrl = routers[index]
+        libp2pConfig.services[`delegatedRouting${index}`] = () => createDelegatedRoutingV1HttpApiClient(routerUrl)
+      }
+
+      libp2pConfig.dns = createDns(init?.dnsResolvers)
+
+      const libp2p = await createLibp2p(libp2pConfig)
+
+      init = await createHelia({
+        libp2p,
+        blockBrokers: [
+          trustlessGateway({
+            allowInsecure: init?.allowInsecure,
+            allowLocal: init?.allowLocal
+          }),
+          bitswap()
+        ],
+        routers: [
+          httpGatewayRouting({
+            gateways: init?.gateways ?? ['https://trustless-gateway.link']
+          }),
+          libp2pRouting(libp2p)
+        ]
+      })
+    } else {
+      init = await createHeliaHTTP({
+        blockBrokers: [
+          trustlessGateway({
+            allowInsecure: init?.allowInsecure,
+            allowLocal: init?.allowLocal
+          })
+        ],
+        routers: [
+          ...(init?.routers ?? ['https://delegated-ipfs.dev']).map((routerUrl) => delegatedHTTPRouting(routerUrl)),
+          httpGatewayRouting({
+            gateways: init?.gateways ?? ['https://trustless-gateway.link']
+          })
+        ],
+        dns: createDns(init?.dnsResolvers)
+      })
+    }
   }
 
   const verifiedFetchInstance = new VerifiedFetchClass({ helia: init }, options)