@helia/verified-fetch 7.2.16 → 8.0.1

package/src/url-resolver.ts

@@ -1,13 +1,17 @@
 import { DoesNotExistError } from '@helia/unixfs/errors'
-import { peerIdFromCID, peerIdFromString } from '@libp2p/peer-id'
+import * as cborg from 'cborg'
 import { exporter, InvalidParametersError, walkPath } from 'ipfs-unixfs-exporter'
+import last from 'it-last'
 import toBuffer from 'it-to-buffer'
+import { base58btc } from 'multiformats/bases/base58'
 import { CID } from 'multiformats/cid'
+import * as Digest from 'multiformats/hashes/digest'
 import QuickLRU from 'quick-lru'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { CODEC_LIBP2P_KEY, SESSION_CACHE_MAX_SIZE, SESSION_CACHE_TTL_MS } from './constants.ts'
 import { abbreviate } from './utils/abbreviate.ts'
 import { applyRedirects } from './utils/apply-redirect.ts'
+import { splitIPNSName } from './utils/ipfs-path-to-cid.ts'
 import { ServerTiming } from './utils/server-timing.ts'
 import type { ResolveURLOptions, ResolveURLResult, URLResolver as URLResolverInterface } from './index.ts'
 import type { DNSLink } from '@helia/dnslink'
@@ -16,6 +20,7 @@ import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { Helia, ProviderOptions, SessionBlockstore } from 'helia'
 import type { Blockstore } from 'interface-blockstore'
 import type { PathEntry, UnixFSEntry } from 'ipfs-unixfs-exporter'
+import type { MultihashDigest } from 'multiformats/cid'
 import type { ProgressOptions } from 'progress-events'
 
 // 1 year in seconds for ipfs content
@@ -137,7 +142,7 @@ export class URLResolver implements URLResolverInterface {
 
     if (result.namespace === 'ipns') {
       // dnslink resolved to IPNS name
-      const ipnsUrl = new URL(`ipns://${result.peerId}${path}`)
+      const ipnsUrl = new URL(`ipns://${base58btc.baseEncode(result.value.bytes)}${path}`)
       resolveResult = await this.resolveIPNSName(ipnsUrl, serverTiming, options)
     } else if (result.namespace === 'ipfs') {
       // dnslink resolved to CID
@@ -161,11 +166,22 @@ export class URLResolver implements URLResolverInterface {
   }
 
   private async resolveIPNSName (url: URL, serverTiming: ServerTiming, options?: ResolveURLOptions): Promise<ResolveURLResult | Response> {
-    const peerId = peerIdFromString(url.hostname)
-    const result = await serverTiming.time(abbreviate('ipns.resolve'), '', this.components.ipnsResolver.resolve(peerId, options))
-    const path = normalizePath(`${result.path ?? ''}/${url.pathname}`)
+    const multihash = parseMultihash(url.hostname)
+    const result = await serverTiming.time(abbreviate('ipns.resolve'), '', last(this.components.ipnsResolver.resolve(multihash, options)))
 
-    const ipfsUrl = new URL(`ipfs://${result.cid}${path}`)
+    if (result == null) {
+      throw new InvalidParametersError('Could not resolve IPNS name')
+    }
+
+    const {
+      ns, name, path
+    } = splitIPNSName(result.value)
+
+    if (ns !== 'ipfs') {
+      throw new InvalidParametersError('IPNS name resolved to non-IPFS path')
+    }
+
+    const ipfsUrl = new URL(`ipfs://${name}${normalizePath(`${path ?? ''}/${url.pathname}`)}`)
     const ipfsResult = await this.resolveIPFSPath(ipfsUrl, serverTiming, options)
 
     if (ipfsResult instanceof Response) {
@@ -173,9 +189,11 @@ export class URLResolver implements URLResolverInterface {
     }
 
     let expires: Date | undefined
+    const data = cborg.decode(result.record.data ?? new Uint8Array(0))
 
-    if (result.record.validityType === 'EOL') {
-      expires = new Date(result.record.validity)
+    // 0 is EOL
+    if (data.ValidityType === 0 && data.Validity instanceof Uint8Array) {
+      expires = new Date(uint8ArrayToString(data.Validity))
     }
 
     return {
@@ -197,7 +215,7 @@ export class URLResolver implements URLResolverInterface {
 
     if (walkPathResult.terminalElement.cid.code === CODEC_LIBP2P_KEY) {
       // special case, peer id encoded as libp2p key CID - interpret as IPNS
-      const ipnsUrl = new URL(`ipns://${peerIdFromCID(walkPathResult.terminalElement.cid)}`)
+      const ipnsUrl = new URL(`ipns://${base58btc.baseEncode(walkPathResult.terminalElement.cid.multihash.bytes)}`)
       const ipnsResult = await this.resolveIPNSName(ipnsUrl, serverTiming, options)
 
       if (ipnsResult instanceof Response) {
@@ -339,3 +357,11 @@ function normalizePath (path: string): string {
 
   return ''
 }
+
+function parseMultihash (str: string): MultihashDigest {
+  if (str.startsWith('1') || str.startsWith('Q')) {
+    return Digest.decode(base58btc.baseDecode(str))
+  }
+
+  return CID.parse(str).multihash
+}

package/src/utils/abbreviate.ts

@@ -13,6 +13,7 @@ const ABBREVIATIONS: Record<string, string> = {
 
   // routers
   'http-gateway-router': 'h',
+  'fallback-router': 'h',
   'libp2p-router': 'l',
 
   // block brokers

package/src/utils/convert-output.ts

@@ -4,12 +4,13 @@ import * as dagPb from '@ipld/dag-pb'
 import * as json from 'multiformats/codecs/json'
 import * as raw from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
 import { CODEC_CBOR } from '../constants.ts'
 import { getContentTypesForCid, MEDIA_TYPE_CBOR, MEDIA_TYPE_DAG_CBOR, MEDIA_TYPE_DAG_JSON, MEDIA_TYPE_JSON, MEDIA_TYPE_OCTET_STREAM, MEDIA_TYPE_RAW } from './content-types.ts'
 import type { AcceptHeader, ContentType } from '../index.ts'
 import type { CID } from 'multiformats/cid'
 
-const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array) => Uint8Array>> = {
+const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>>> = {
   [dagCbor.code]: {
     [MEDIA_TYPE_CBOR]: (buf) => {
       return buf
@@ -18,7 +19,8 @@ const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array) => Uint8Array
       return buf
     },
     [MEDIA_TYPE_JSON]: (buf) => {
-      return dagJson.encode(dagCbor.decode(buf))
+      // TODO: remove withArrayBuffer when dag-json is explicit about it's return type
+      return withArrayBuffer(dagJson.encode(dagCbor.decode(buf)))
     },
     [MEDIA_TYPE_DAG_JSON]: () => {
       throw new Error('Cannot perform conversion since IPIP-0524')
@@ -41,7 +43,8 @@ const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array) => Uint8Array
       return buf
     },
     [MEDIA_TYPE_DAG_JSON]: (buf) => {
-      return dagJson.encode(dagCbor.decode(buf))
+      // TODO: remove withArrayBuffer when dag-json is explicit about it's return type
+      return withArrayBuffer(dagJson.encode(dagCbor.decode(buf)))
     },
     [MEDIA_TYPE_RAW]: (buf) => {
       return buf
@@ -75,7 +78,8 @@ const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array) => Uint8Array
       return buf
     },
     [MEDIA_TYPE_DAG_CBOR]: (buf) => {
-      return dagCbor.encode(json.decode(buf))
+      // TODO: remove withArrayBuffer when dag-cbor is explicit about it's return type
+      return withArrayBuffer(dagCbor.encode(json.decode(buf)))
     },
     [MEDIA_TYPE_JSON]: (buf) => {
       return buf
@@ -135,13 +139,15 @@ const CONVERSIONS: Record<number, Record<string, (buf: Uint8Array) => Uint8Array
       return buf
     },
     [MEDIA_TYPE_DAG_CBOR]: (buf) => {
-      return dagCbor.encode(buf)
+      // TODO: remove withArrayBuffer when dag-cbor is explicit about it's return type
+      return withArrayBuffer(dagCbor.encode(buf))
     },
     [MEDIA_TYPE_JSON]: (buf) => {
       return buf
     },
     [MEDIA_TYPE_DAG_JSON]: (buf) => {
-      return dagJson.encode(buf)
+      // TODO: remove withArrayBuffer when dag-json is explicit about it's return type
+      return withArrayBuffer(dagJson.encode(buf))
     },
     [MEDIA_TYPE_RAW]: (buf) => {
       return buf
@@ -163,7 +169,7 @@ export interface ConvertedOutput {
  * the deserialized value to that format and serialize it back to a block -
  * return the first successful result.
  */
-export function convertOutput (cid: CID, block: Uint8Array, accept: AcceptHeader[]): { contentType: ContentType, output: Uint8Array } {
+export function convertOutput (cid: CID, block: Uint8Array<ArrayBuffer>, accept: AcceptHeader[]): { contentType: ContentType, output: Uint8Array<ArrayBuffer> } {
   if (accept.length === 0) {
     // return current format
     return {

package/src/utils/ipfs-path-to-cid.ts

@@ -0,0 +1,9 @@
+export function splitIPNSName (path: string): { ns: string, name: string, path: string } {
+  const [, ns, name, ...rest] = path.trim().split('/')
+
+  return {
+    ns,
+    name,
+    path: rest.length > 0 ? `${rest.join('/')}` : ''
+  }
+}

package/src/utils/libp2p-defaults.browser.ts

@@ -1,8 +1,8 @@
+import { libp2pDefaults } from '@helia/libp2p'
 import { webRTCDirect } from '@libp2p/webrtc'
 import { webSockets } from '@libp2p/websockets'
-import { libp2pDefaults } from 'helia'
 import type { ServiceFactoryMap } from './libp2p-types.ts'
-import type { DefaultLibp2pServices } from 'helia'
+import type { DefaultLibp2pServices } from '@helia/libp2p'
 import type { Libp2pOptions } from 'libp2p'
 
 type ServiceMap = Pick<DefaultLibp2pServices, 'dcutr' | 'identify' | 'keychain' | 'ping'>

package/src/utils/libp2p-defaults.ts

@@ -1,9 +1,7 @@
+import { libp2pDefaults } from '@helia/libp2p'
 import { kadDHT } from '@libp2p/kad-dht'
-import { libp2pDefaults } from 'helia'
-import { ipnsSelector } from 'ipns/selector'
-import { ipnsValidator } from 'ipns/validator'
 import type { ServiceFactoryMap } from './libp2p-types.ts'
-import type { DefaultLibp2pServices } from 'helia'
+import type { DefaultLibp2pServices } from '@helia/libp2p'
 import type { Libp2pOptions } from 'libp2p'
 
 type ServiceMap = Pick<DefaultLibp2pServices, 'autoNAT' | 'dcutr' | 'dht' | 'identify' | 'keychain' | 'ping' | 'upnp'>
@@ -17,13 +15,7 @@ export function getLibp2pConfig (): Libp2pOptions & Required<Pick<Libp2pOptions,
     autoNAT: libp2pDefaultOptions.services.autoNAT,
     dcutr: libp2pDefaultOptions.services.dcutr,
     dht: kadDHT({
-      clientMode: true,
-      validators: {
-        ipns: ipnsValidator
-      },
-      selectors: {
-        ipns: ipnsSelector
-      }
+      clientMode: true
     }),
     identify: libp2pDefaultOptions.services.identify,
     keychain: libp2pDefaultOptions.services.keychain,

package/src/verified-fetch.ts

@@ -252,26 +252,26 @@ export class VerifiedFetch {
           options?.onProgress?.(evt)
 
           if (evt.type === 'helia:routing:find-providers:start') {
-            routingTimers[evt.detail.routing] = {
+            routingTimers[evt.detail.router] = {
               start: performance.now(),
               found: 0
             }
           } else if (evt.type === 'helia:routing:find-providers:provider') {
-            if (routingTimers[evt.detail.routing] == null) {
+            if (routingTimers[evt.detail.router] == null) {
               return
             }
 
-            routingTimers[evt.detail.routing].found++
+            routingTimers[evt.detail.router].found++
 
-            serverTiming.add(abbreviate('found-provider'), `${abbreviate(evt.detail.routing)},${truncate(evt.detail.provider.id)}`, performance.now() - routingTimers[evt.detail.routing].start)
+            serverTiming.add(abbreviate('found-provider'), `${abbreviate(evt.detail.router)},${truncate(evt.detail.provider.id)}`, performance.now() - routingTimers[evt.detail.router].start)
           } else if (evt.type === 'helia:routing:find-providers:end') {
-            const routing = routingTimers[evt.detail.routing]
+            const routing = routingTimers[evt.detail.router]
 
             if (routing == null) {
               return
             }
 
-            serverTiming.add(abbreviate('find-providers'), `${abbreviate(evt.detail.routing)},${routing.found}`, performance.now() - routing.start)
+            serverTiming.add(abbreviate('find-providers'), `${abbreviate(evt.detail.router)},${routing.found}`, performance.now() - routing.start)
           } else if (evt.type === 'helia:block-broker:connect') {
             connectTimers[`connect-${evt.detail.broker}-${evt.detail.provider}`] = {
               start: performance.now(),