@helia/verified-fetch 7.2.15 → 8.0.0

package/src/index.ts

@@ -100,23 +100,19 @@
  * You can see variations of Helia and js-libp2p configuration options at <https://ipfs.github.io/helia/interfaces/helia.HeliaInit.html>.
  *
  * ```typescript
- * import { trustlessGateway } from '@helia/block-brokers'
- * import { createHeliaHTTP } from '@helia/http'
+ * import { createHeliaLight } from 'helia'
+ * import { withHTTP } from '@helia/http'
  * import { delegatedHTTPRouting, httpGatewayRouting } from '@helia/routers'
  * import { createVerifiedFetch } from '@helia/verified-fetch'
  *
  * const fetch = await createVerifiedFetch(
- *   await createHeliaHTTP({
- *     blockBrokers: [
- *       trustlessGateway()
+ *   await withHTTP(createHeliaLight(), {
+ *     delegatedRouters: [
+ *       'http://delegated-ipfs.dev'
  *     ],
- *     routers: [
- *       delegatedHTTPRouting({
- *         url: 'http://delegated-ipfs.dev'
- *       }),
- *       httpGatewayRouting({
- *         gateways: ['https://mygateway.example.net', 'https://trustless-gateway.link']
- *       })
+ *     recursiveGateways: [
+ *       'https://mygateway.example.net',
+ *       'https://trustless-gateway.link'
  *     ]
  *   })
  * )
@@ -856,19 +852,23 @@
  * fetch if not.
  */
 
-import { bitswap, trustlessGateway } from '@helia/block-brokers'
-import { delegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
-import { httpGatewayRouting, libp2pRouting } from '@helia/routers'
+import { withBitswap } from '@helia/bitswap'
+import { delegatedRoutingV1HttpApiClientContentRouting, delegatedRoutingV1HttpApiClientPeerRouting } from '@helia/delegated-routing-v1-http-api-client'
+import { withHTTP } from '@helia/http'
+import { withLibp2p } from '@helia/libp2p'
+import * as dagCbor from '@ipld/dag-cbor'
+import * as dagJson from '@ipld/dag-json'
 import { dns } from '@multiformats/dns'
-import { createHelia } from 'helia'
+import { createHeliaLight } from 'helia'
 import { createLibp2p } from 'libp2p'
+import * as json from 'multiformats/codecs/json'
 import { getLibp2pConfig } from './utils/libp2p-defaults.ts'
 import { VerifiedFetch as VerifiedFetchClass } from './verified-fetch.ts'
 import type { RangeHeader } from './utils/get-range-header.ts'
 import type { ServerTiming } from './utils/server-timing.ts'
 import type { RequestedMimeType } from './verified-fetch.ts'
 import type { DNSLink, ResolveProgressEvents as ResolveDNSLinkProgressEvents } from '@helia/dnslink'
-import type { GetBlockProgressEvents, Helia, ProviderOptions, Routing } from '@helia/interface'
+import type { GetBlockProgressEvents, Helia, ProviderOptions } from '@helia/interface'
 import type { ResolveProgressEvents as ResolveIPNSNameProgressEvents, IPNSRoutingProgressEvents, IPNSResolver } from '@helia/ipns'
 import type { AbortOptions, Libp2p, ServiceMap, Logger, PeerId, PublicKey } from '@libp2p/interface'
 import type { DNSResolvers, DNS } from '@multiformats/dns'
@@ -1098,7 +1098,7 @@ export interface CreateVerifiedFetchInit {
 
   /**
    * 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
+   * pass a list of DNS resolvers that we will provide to the `@helia/ipns`
    * instance for you. You must construct them using the `dnsJsonOverHttps` or
    * `dnsOverHttps` functions exported from `@helia/ipns/dns-resolvers`.
    *
@@ -1109,12 +1109,19 @@ export interface CreateVerifiedFetchInit {
   dnsResolvers?: DNSResolver[] | DNSResolvers
 
   /**
-   * By default sha256, sha512 and identity hashes are supported for
-   * retrieval operations. To retrieve blocks by CIDs using other hashes
-   * pass appropriate MultihashHashers here.
+   * By default sha256 and identity hashes are supported for retrieval
+   * operations. To retrieve blocks by CIDs using other hashes pass
+   * appropriate MultihashHashers here.
    */
   hashers?: HeliaInit['hashers']
 
+  /**
+   * By default raw, dag-pb, dag-json, dag-cbor, json and cbor codecs are
+   * supported for retrieval operations. To retrieve blocks with CIDs that use
+   * other codecs pass appropriate BlockCodecs here.
+   */
+  codecs?: HeliaInit['codecs']
+
   /**
    * By default we will not connect to any HTTP Gateways providers over local or
    * loopback addresses, this is because they are typically running on remote
@@ -1354,7 +1361,18 @@ export interface ResolveURLOptions extends AbortOptions, ProviderOptions, Progre
 
 export interface ResolveURLResult {
   url: URL
-  ttl: number
+
+  /**
+   * How long this result is valid for - in general re-resolving this URL will
+   * result in the same final URL within this many seconds
+   */
+  ttl?: number
+
+  /**
+   * This can represent an IPNS records EOL validity expiration
+   */
+  expires?: Date
+
   blockstore: Blockstore
   ipfsRoots: CID[]
   terminalElement: PathEntry
@@ -1374,6 +1392,7 @@ export interface URLResolver {
  */
 export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchInit, options?: CreateVerifiedFetchOptions): Promise<VerifiedFetch> {
   let libp2p: Libp2p<any> | undefined
+
   if (!isHelia(init)) {
     const dns = createDns(init?.dnsResolvers)
 
@@ -1382,35 +1401,40 @@ export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchIni
 
     const delegatedRouters = init?.routers ?? ['https://delegated-ipfs.dev']
     for (let index = 0; index < delegatedRouters.length; index++) {
-      libp2pConfig.services[`delegatedRouting${index}`] = delegatedRoutingV1HttpApiClient({
+      libp2pConfig.services[`delegatedContentRouting${index}`] = delegatedRoutingV1HttpApiClientContentRouting({
+        url: delegatedRouters[index]
+      })
+      libp2pConfig.services[`delegatedPeerRouting${index}`] = delegatedRoutingV1HttpApiClientPeerRouting({
         url: delegatedRouters[index]
       })
     }
+
     // merge any passed options from init.libp2pConfig into libp2pConfig if it exists
     if (init?.libp2pConfig != null) {
       Object.assign(libp2pConfig, init.libp2pConfig)
     }
-    libp2p = await createLibp2p(libp2pConfig)
 
-    const blockBrokers = [
-      bitswap()
-    ]
-    const routers: Array<Partial<Routing>> = [
-      libp2pRouting(libp2p)
-    ]
-    if (init?.gateways == null || init.gateways.length > 0) {
-      // if gateways is null, or set to a non-empty array, use trustless gateways.
-      blockBrokers.push(trustlessGateway({ allowInsecure: init?.allowInsecure, allowLocal: init?.allowLocal }))
-      routers.push(httpGatewayRouting({ gateways: init?.gateways ?? ['https://trustless-gateway.link'] }))
-    }
+    libp2p = await createLibp2p(libp2pConfig)
 
-    init = await createHelia({
-      libp2p,
-      blockBrokers,
+    init = await withBitswap(withLibp2p(withHTTP(createHeliaLight({
       dns,
-      routers,
-      hashers: init?.hashers
-    })
+      hashers: init?.hashers,
+      codecs: [
+        dagCbor,
+        dagJson,
+        json,
+        ...(init?.codecs ?? [])
+      ]
+    }), {
+      delegatedRouters,
+      recursiveGateways: init?.gateways ?? [
+        'https://trustless-gateway.link'
+      ],
+      trustlessGatewayBlockBrokerInit: {
+        allowInsecure: init?.allowInsecure,
+        allowLocal: init?.allowLocal
+      }
+    }), libp2p)).start()
     init.logger.forComponent('helia:verified-fetch').trace('created verified-fetch with libp2p config: %j', libp2pConfig)
   }
 

package/src/plugins/plugin-handle-ipns-record.ts

@@ -1,10 +1,14 @@
+import { IPNSEntry } from '@helia/ipns'
+import * as dagCbor from '@ipld/dag-cbor'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { marshalIPNSRecord } from 'ipns'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { CONTENT_TYPE_IPNS, MEDIA_TYPE_IPNS_RECORD } from '../utils/content-types.ts'
 import { getContentDispositionFilename } from '../utils/get-content-disposition-filename.ts'
+import { splitIPNSName } from '../utils/ipfs-path-to-cid.ts'
 import { badRequestResponse, okResponse } from '../utils/responses.ts'
 import { BasePlugin } from './plugin-base.ts'
 import type { PluginContext } from '../index.ts'
+import type { IPNSRecordData, IPNSResolveResult } from '@helia/ipns'
 import type { PeerId } from '@libp2p/interface'
 
 /**
@@ -19,7 +23,7 @@ export class IpnsRecordPlugin extends BasePlugin {
     return accept.some(header => header.contentType.mediaType === MEDIA_TYPE_IPNS_RECORD)
   }
 
-  async handle (context: Pick<PluginContext, 'resource' | 'url' | 'range' | 'redirected' | 'signal' | 'onProgress'>): Promise<Response> {
+  async handle (context: Pick<PluginContext, 'resource' | 'url' | 'range' | 'redirected' | 'signal' | 'onProgress' | 'ttl' | 'expires'>): Promise<Response> {
     const { resource, url, range } = context
     const { ipnsResolver } = this.pluginOptions
 
@@ -43,8 +47,30 @@ export class IpnsRecordPlugin extends BasePlugin {
       return badRequestResponse(resource, err)
     }
 
-    const result = await ipnsResolver.resolve(peerId, context)
-    const block = marshalIPNSRecord(result.record)
+    let result: IPNSResolveResult | undefined
+
+    for await (const res of ipnsResolver.resolve(peerId.toCID().multihash, context)) {
+      result = res
+    }
+
+    if (result == null) {
+      const err = new Error(`Could not resolve IPNS record for ${peerId}`)
+      this.log.error('could not parse peer id from IPNS url %s', resource, err)
+
+      return badRequestResponse(resource, err)
+    }
+
+    const block = IPNSEntry.encode(result.record)
+    const data = dagCbor.decode<IPNSRecordData>(result.record.data ?? new Uint8Array(0))
+
+    // 0 is EOL
+    // @ts-expect-error TODO: remove TypeScript enums
+    if (data.ValidityType === 0 && data.Validity instanceof Uint8Array) {
+      const eol = new Date(uint8ArrayToString(data.Validity))
+
+      context.expires = eol
+      context.ttl = Math.round(Number((result.record.ttl ?? 0n) / BigInt(1e9)))
+    }
 
     return okResponse(resource, block, {
       redirected: context.redirected,
@@ -54,8 +80,7 @@ export class IpnsRecordPlugin extends BasePlugin {
         'content-disposition': `attachment; ${
           getContentDispositionFilename(url.searchParams.get('filename') ?? `${peerId}${CONTENT_TYPE_IPNS.extension}`)
         }`,
-        'x-ipfs-roots': result.cid.toV1().toString(),
-        'cache-control': `public, max-age=${Number((result.record.ttl ?? 0n) / BigInt(1e9))}`,
+        'x-ipfs-roots': splitIPNSName(result.value).name,
         'accept-ranges': 'none'
       }
     })

package/src/plugins/plugin-handle-unixfs.ts

@@ -6,6 +6,7 @@ import last from 'it-last'
 import itToBrowserReadableStream from 'it-to-browser-readablestream'
 import toBuffer from 'it-to-buffer'
 import * as raw from 'multiformats/codecs/raw'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
 import { MEDIA_TYPE_OCTET_STREAM, MEDIA_TYPE_DAG_PB } from '../utils/content-types.ts'
 import { getContentDispositionFilename } from '../utils/get-content-disposition-filename.ts'
 import { badGatewayResponse, movedPermanentlyResponse, partialContentResponse, okResponse } from '../utils/responses.ts'
@@ -147,15 +148,17 @@ export class UnixFSPlugin extends BasePlugin {
             Name: dirEntry.name,
             Hash: dirEntry.cid,
 
-            // @ts-expect-error needs https://github.com/ipfs/js-ipfs-unixfs/pull/484
-            Tsize: dirEntry.size
+            // TODO: downcast bigint to number until @ipld/dag-pb supports the
+            // correct field type
+            Tsize: Number(dirEntry.size)
           })
         }
 
-        block = dagPb.encode({
+        // TODO: remove withArrayBuffer when dag-pb is explicit about it's return type
+        block = withArrayBuffer(dagPb.encode({
           Data: data.Data,
           Links: links.sort((a, b) => a.Name?.localeCompare(b.Name ?? '') ?? 0)
-        })
+        }))
       }
 
       return okResponse(resource, block, {

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,22 +166,43 @@ 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) {
       return ipfsResult
     }
 
+    let expires: Date | undefined
+    const data = cborg.decode(result.record.data ?? new Uint8Array(0))
+
+    // 0 is EOL
+    if (data.ValidityType === 0 && data.Validity instanceof Uint8Array) {
+      expires = new Date(uint8ArrayToString(data.Validity))
+    }
+
     return {
       ...ipfsResult,
       url,
-      // IPNS ttl is in nanoseconds, convert to seconds
-      ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9))
+      // IPNS ttl is in nanoseconds, convert to seconds and round to the nearest
+      // integer
+      ttl: Math.round(Number((result.record.ttl ?? 0n) / BigInt(1e9))),
+      expires
     }
   }
 
@@ -189,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) {
@@ -331,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/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/utils/response-headers.ts

@@ -4,42 +4,60 @@ interface CacheControlHeaderOptions {
   /**
    * This should be seconds as a number.
    *
-   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#response_directives
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#response_directives
    */
   ttl?: number
+
+  /**
+   * This can represent an IPNS record's EOL validity
+   */
+  expires?: Date
   protocol: string
   response: Response
 }
 
 /**
- * Implementations may place an upper bound on any TTL received, as noted in Section 8 of [rfc2181].
+ * Implementations may place an upper bound on any TTL received, as noted in
+ * Section 8 of [rfc2181].
+ *
  * If TTL value is unknown, implementations should not send a Cache-Control
- * No matter if TTL value is known or not, implementations should always send a Last-Modified header with the timestamp of the record resolution.
+ *
+ * No matter if TTL value is known or not, implementations should always send a
+ * Last-Modified header with the timestamp of the record resolution.
  *
  * @see https://specs.ipfs.tech/http-gateways/path-gateway/#cache-control-response-header
  */
-export function setCacheControlHeader ({ ttl, protocol, response }: CacheControlHeaderOptions): void {
-  if (response.headers.has('cache-control')) {
-    // don't set the header if it's already set by a plugin
-    return
-  }
-
-  let headerValue: string
+export function setCacheControlHeader ({ ttl, expires, protocol, response }: CacheControlHeaderOptions): void {
+  let cacheControl: string
 
   if (protocol === 'ipfs:') {
-    headerValue = 'public, max-age=29030400, immutable'
+    cacheControl = 'public, max-age=29030400, immutable'
   } else if (ttl == null) {
     /**
-     * default limit for unknown TTL: "use 5 minute as default fallback when it is not available."
+     * default limit for unknown TTL: "use 5 minute as default fallback when it
+     * is not available."
      *
      * @see https://github.com/ipfs/boxo/issues/329#issuecomment-1995236409
      */
-    headerValue = 'public, max-age=300'
+    cacheControl = 'public, max-age=300'
   } else {
-    headerValue = `public, max-age=${ttl}`
+    cacheControl = `public, max-age=${ttl}`
+  }
+
+  if (expires != null) {
+    const lifetimeRemaining = Math.max(0, Math.round((expires.getTime() - Date.now()) / 1000))
+    cacheControl += `, stale-while-revalidate=${lifetimeRemaining}, stale-if-error=${lifetimeRemaining}`
+
+    // add the expires header if it's not been set by a plugin
+    if (!response.headers.has('expires')) {
+      response.headers.set('expires', expires.toUTCString())
+    }
   }
 
-  response.headers.set('cache-control', headerValue)
+  if (!response.headers.has('cache-control')) {
+    // don't set the cache-control header if it's already set by a plugin
+    response.headers.set('cache-control', cacheControl)
+  }
 }
 
 /**

package/src/verified-fetch.ts

@@ -198,15 +198,17 @@ export class VerifiedFetch {
           return notAcceptableResponse(resource, requestedMimeTypes, [])
         }
 
-        return this.handleFinalResponse(await ipnsRecordPlugin.handle({
+        const context = {
           ...options,
           range,
           url,
           resource,
-          redirected: false
-        }), withServerTiming, {
+          redirected: false,
           serverTiming
-        })
+        }
+
+        // @ts-expect-error headers type is wrong
+        return this.handleFinalResponse(await ipnsRecordPlugin.handle(context), withServerTiming, context)
       }
 
       const resolveResult = await this.urlResolver.resolve(url, serverTiming, options)
@@ -421,6 +423,7 @@ export class VerifiedFetch {
       setCacheControlHeader({
         response,
         ttl: context.ttl,
+        expires: context.expires,
         protocol: context.url.protocol
       })
     }