@helia/delegated-routing-v1-http-api-client 6.0.0 → 7.0.0

package/dist/typedoc-urls.json

@@ -7,16 +7,20 @@
   ".:DelegatedRoutingV1HttpApiClientInit": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.DelegatedRoutingV1HttpApiClientInit.html",
   "FilterOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.FilterOptions.html",
   ".:FilterOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.FilterOptions.html",
-  "GetIPNSOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.GetIPNSOptions.html",
-  ".:GetIPNSOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.GetIPNSOptions.html",
   "PeerRecord": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.PeerRecord.html",
   ".:PeerRecord": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/interfaces/_helia_delegated-routing-v1-http-api-client.PeerRecord.html",
   "GetClosestPeersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetClosestPeersOptions.html",
   ".:GetClosestPeersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetClosestPeersOptions.html",
+  "GetIPNSOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetIPNSOptions.html",
+  ".:GetIPNSOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetIPNSOptions.html",
   "GetPeersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetPeersOptions.html",
   ".:GetPeersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetPeersOptions.html",
   "GetProvidersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetProvidersOptions.html",
   ".:GetProvidersOptions": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/types/_helia_delegated-routing-v1-http-api-client.GetProvidersOptions.html",
   "delegatedRoutingV1HttpApiClient": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClient.html",
-  ".:delegatedRoutingV1HttpApiClient": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClient.html"
+  ".:delegatedRoutingV1HttpApiClient": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClient.html",
+  "delegatedRoutingV1HttpApiClientContentRouting": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClientContentRouting.html",
+  ".:delegatedRoutingV1HttpApiClientContentRouting": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClientContentRouting.html",
+  "delegatedRoutingV1HttpApiClientPeerRouting": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClientPeerRouting.html",
+  ".:delegatedRoutingV1HttpApiClientPeerRouting": "https://ipfs.github.io/helia-delegated-routing-v1-http-api/functions/_helia_delegated-routing-v1-http-api-client.delegatedRoutingV1HttpApiClientPeerRouting.html"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/delegated-routing-v1-http-api-client",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "A Delegated Routing V1 HTTP API client",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia-delegated-routing-v1-http-api/tree/main/packages/client#readme",
@@ -29,7 +29,8 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "import": "./dist/src/index.js",
+      "module-sync": "./dist/src/index.js"
     }
   },
   "release": {
@@ -144,20 +145,20 @@
     "@multiformats/multiaddr": "^13.0.1",
     "any-signal": "^4.1.1",
     "browser-readablestream-to-it": "^2.0.9",
-    "ipns": "^10.0.2",
     "it-first": "^3.0.8",
     "it-map": "^3.1.3",
-    "it-ndjson": "^1.1.3",
-    "multiformats": "^13.3.6",
+    "it-ndjson": "^2.0.0",
+    "multiformats": "^14.0.0",
     "p-defer": "^4.0.1",
     "p-queue": "^9.0.0",
-    "uint8arrays": "^5.1.0"
+    "uint8arrays": "^6.1.1"
   },
   "devDependencies": {
     "@libp2p/crypto": "^5.1.3",
     "@libp2p/logger": "^6.0.5",
-    "aegir": "^47.0.10",
+    "aegir": "^48.0.4",
     "body-parser": "^2.2.0",
+    "ipns": "^11.0.0",
     "it-all": "^3.0.8",
     "wherearewe": "^2.0.1"
   },

package/src/client.ts

@@ -1,20 +1,17 @@
-import { InvalidParametersError, NotFoundError, contentRoutingSymbol, isPeerId, peerRoutingSymbol, setMaxListeners } from '@libp2p/interface'
+import { InvalidParametersError, NotFoundError, setMaxListeners } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { anySignal } from 'any-signal'
 import toIt from 'browser-readablestream-to-it'
-import { unmarshalIPNSRecord, marshalIPNSRecord, multihashToIPNSRoutingKey } from 'ipns'
-import { ipnsValidator } from 'ipns/validator'
 import { parse as ndjson } from 'it-ndjson'
 import { CID } from 'multiformats/cid'
 import defer from 'p-defer'
 import PQueue from 'p-queue'
-import { BadResponseError, InvalidRequestError } from './errors.js'
-import { DelegatedRoutingV1HttpApiClientContentRouting, DelegatedRoutingV1HttpApiClientPeerRouting } from './routings.js'
-import type { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientInterface, DelegatedRoutingV1HttpApiClientInit, GetProvidersOptions, GetPeersOptions, GetIPNSOptions, PeerRecord, DelegatedRoutingV1HttpApiClientComponents, GetClosestPeersOptions } from './index.js'
-import type { ContentRouting, PeerRouting, AbortOptions, PeerId, Logger } from '@libp2p/interface'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import { BadResponseError, InvalidRequestError } from './errors.ts'
+import type { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientInterface, DelegatedRoutingV1HttpApiClientInit, GetProvidersOptions, GetPeersOptions, GetIPNSOptions, PeerRecord, DelegatedRoutingV1HttpApiClientComponents, GetClosestPeersOptions } from './index.ts'
+import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { IPNSRecord } from 'ipns'
 
 const defaultValues = {
   concurrentRequests: 4,
@@ -29,8 +26,6 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
   private readonly httpQueue: PQueue
   private readonly shutDownController: AbortController
   private readonly timeout: number
-  private readonly contentRouting: ContentRouting
-  private readonly peerRouting: PeerRouting
   private readonly filterAddrs?: string[]
   private readonly filterProtocols?: string[]
   private readonly inFlightRequests: Map<string, Promise<Response>>
@@ -55,21 +50,11 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     this.timeout = init.timeout ?? defaultValues.timeout
     this.filterAddrs = init.filterAddrs
     this.filterProtocols = init.filterProtocols
-    this.contentRouting = new DelegatedRoutingV1HttpApiClientContentRouting(this)
-    this.peerRouting = new DelegatedRoutingV1HttpApiClientPeerRouting(this)
 
     this.cacheName = init.cacheName ?? defaultValues.cacheName
     this.cacheTTL = init.cacheTTL ?? defaultValues.cacheTTL
   }
 
-  get [contentRoutingSymbol] (): ContentRouting {
-    return this.contentRouting
-  }
-
-  get [peerRoutingSymbol] (): PeerRouting {
-    return this.peerRouting
-  }
-
   isStarted (): boolean {
     return this.started
   }
@@ -120,15 +105,14 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
 
       // https://specs.ipfs.tech/routing/http-routing-v1/
       const url = new URL(`${this.url}routing/v1/providers/${cid}`)
-
       this.#addFilterParams(url, options.filterAddrs, options.filterProtocols)
-      const getOptions = {
+
+      const res = await this.#makeRequest(url.toString(), {
         headers: {
           accept: 'application/x-ndjson, application/json;q=0.8'
         },
         signal
-      }
-      const res = await this.#makeRequest(url.toString(), getOptions)
+      })
 
       if (!res.ok) {
         // Per IPIP-0513: Handle 404 as empty results (not an error)
@@ -194,8 +178,8 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     }
   }
 
-  async * getPeers (peerId: PeerId, options: GetPeersOptions = {}): AsyncGenerator<PeerRecord> {
-    this.log('getPeers starts: %c', peerId)
+  async * getPeers (cid: CID, options: GetPeersOptions = {}): AsyncGenerator<PeerRecord> {
+    this.log('getPeers starts: %c', cid)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -212,11 +196,15 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
       await onStart.promise
 
       // https://specs.ipfs.tech/routing/http-routing-v1/
-      const url = new URL(`${this.url}routing/v1/peers/${peerId.toCID().toString()}`)
+      const url = new URL(`${this.url}routing/v1/peers/${cid}`)
       this.#addFilterParams(url, options.filterAddrs, options.filterProtocols)
 
-      const getOptions = { headers: { Accept: 'application/x-ndjson' }, signal }
-      const res = await this.#makeRequest(url.toString(), getOptions)
+      const res = await this.#makeRequest(url.toString(), {
+        headers: {
+          Accept: 'application/x-ndjson'
+        },
+        signal
+      })
 
       // Per IPIP-0513: Handle 404 as empty results (not an error)
       // Old servers return 404, new servers return 200 with empty array
@@ -260,19 +248,17 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     } finally {
       signal.clear()
       onFinish.resolve()
-      this.log('getPeers finished: %c', peerId)
+      this.log('getPeers finished: %c', cid)
     }
   }
 
-  async * getClosestPeers (key: CID | PeerId, options: GetClosestPeersOptions = {}): AsyncGenerator<PeerRecord> {
+  async * getClosestPeers (key: CID, options: GetClosestPeersOptions = {}): AsyncGenerator<PeerRecord> {
     let target: string
 
-    if (isPeerId(key)) {
-      target = key.toCID().toString()
-    } else if (CID.asCID(key) === key || key instanceof CID) {
+    if (CID.asCID(key) === key || key instanceof CID) {
       target = key.toV1().toString()
     } else {
-      throw new InvalidParametersError('Key must be CID or PeerId')
+      throw new InvalidParametersError('Key must be CID')
     }
 
     this.log('getClosestPeers starts: %s', target)
@@ -295,8 +281,12 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
       const url = new URL(`${this.url}routing/v1/dht/closest/peers/${target}`)
       this.#addFilterParams(url, options.filterAddrs, options.filterProtocols)
 
-      const getOptions = { headers: { Accept: 'application/x-ndjson' }, signal }
-      const res = await this.#makeRequest(url.toString(), getOptions)
+      const res = await this.#makeRequest(url.toString(), {
+        headers: {
+          Accept: 'application/x-ndjson'
+        },
+        signal
+      })
 
       // Per IPIP-0513: Handle 404 as empty results (not an error)
       // Old servers return 404, new servers return 200 with empty array
@@ -344,8 +334,8 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     }
   }
 
-  async getIPNS (libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, options: GetIPNSOptions = {}): Promise<IPNSRecord> {
-    this.log('getIPNS starts: %s', libp2pKey)
+  async getIPNS (cid: CID, options: GetIPNSOptions = {}): Promise<Uint8Array<ArrayBuffer>> {
+    this.log('getIPNS starts: %c', cid)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -359,13 +349,17 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     })
 
     // https://specs.ipfs.tech/routing/http-routing-v1/
-    const resource = `${this.url}routing/v1/ipns/${libp2pKey}`
+    const resource = `${this.url}routing/v1/ipns/${cid}`
 
     try {
       await onStart.promise
 
-      const getOptions = { headers: { Accept: 'application/vnd.ipfs.ipns-record' }, signal }
-      const res = await this.#makeRequest(resource, getOptions)
+      const res = await this.#makeRequest(resource, {
+        headers: {
+          Accept: 'application/vnd.ipfs.ipns-record'
+        },
+        signal
+      })
 
       this.log('getIPNS GET %s %d', resource, res.status)
 
@@ -398,13 +392,8 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
       }
 
       const buf = await res.arrayBuffer()
-      const body = new Uint8Array(buf, 0, buf.byteLength)
 
-      if (options.validate !== false) {
-        await ipnsValidator(multihashToIPNSRoutingKey(libp2pKey.multihash), body)
-      }
-
-      return unmarshalIPNSRecord(body)
+      return new Uint8Array(buf, 0, buf.byteLength)
     } catch (err: any) {
       this.log.error('getIPNS GET %s error - %e', resource, err)
 
@@ -412,11 +401,11 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     } finally {
       signal.clear()
       onFinish.resolve()
-      this.log('getIPNS finished: %s', libp2pKey)
+      this.log('getIPNS finished: %c', cid)
     }
   }
 
-  async putIPNS (libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, record: IPNSRecord, options: AbortOptions = {}): Promise<void> {
+  async putIPNS (libp2pKey: CID, record: Uint8Array, options: AbortOptions = {}): Promise<void> {
     this.log('putIPNS starts: %c', libp2pKey)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
@@ -436,10 +425,14 @@ export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpAp
     try {
       await onStart.promise
 
-      const body = marshalIPNSRecord(record)
-
-      const getOptions = { method: 'PUT', headers: { 'Content-Type': 'application/vnd.ipfs.ipns-record' }, body, signal }
-      const res = await this.#makeRequest(resource, getOptions)
+      const res = await this.#makeRequest(resource, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/vnd.ipfs.ipns-record'
+        },
+        body: withArrayBuffer(record),
+        signal
+      })
 
       this.log('putIPNS PUT %s %d', resource, res.status)
 

package/src/constants.ts

@@ -0,0 +1 @@
+export const CODE_LIBP2P_KEY = 0x72

package/src/index.ts

@@ -98,10 +98,10 @@
  * ```
  */
 
-import { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientClass } from './client.js'
-import type { AbortOptions, ComponentLogger, PeerId } from '@libp2p/interface'
+import { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientClass } from './client.ts'
+import { DelegatedRoutingV1HttpApiClientContentRouting, DelegatedRoutingV1HttpApiClientPeerRouting } from './routings.ts'
+import type { AbortOptions, ComponentLogger, ContentRouting, PeerId, PeerRouting } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { IPNSRecord } from 'ipns'
 import type { CID } from 'multiformats/cid'
 
 /**
@@ -179,16 +179,7 @@ export interface DelegatedRoutingV1HttpApiClientComponents {
   logger: ComponentLogger
 }
 
-export interface GetIPNSOptions extends AbortOptions {
-  /**
-   * By default incoming IPNS records are validated, pass false here to skip
-   * validation and just return the record.
-   *
-   * @default true
-   */
-  validate?: boolean
-}
-
+export type GetIPNSOptions = AbortOptions
 export type GetProvidersOptions = FilterOptions & AbortOptions
 export type GetPeersOptions = FilterOptions & AbortOptions
 export type GetClosestPeersOptions = FilterOptions & AbortOptions
@@ -207,25 +198,25 @@ export interface DelegatedRoutingV1HttpApiClient {
 
   /**
    * Returns an async generator of {@link PeerRecord}s for the provided
-   * {@link PeerId}
+   * {@link CID}
    */
-  getPeers(peerId: PeerId, options?: GetPeersOptions): AsyncGenerator<PeerRecord>
+  getPeers(cid: CID, options?: GetPeersOptions): AsyncGenerator<PeerRecord>
 
   /**
    * Returns an async generator of {@link PeerRecord}s of the closest peers to
    * the supplied key
    */
-  getClosestPeers (key: CID | PeerId, options?: GetClosestPeersOptions): AsyncGenerator<PeerRecord>
+  getClosestPeers (cid: CID, options?: GetClosestPeersOptions): AsyncGenerator<PeerRecord>
 
   /**
-   * Returns a promise of a {@link IPNSRecord} for the given {@link MultihashDigest}
+   * Returns a promise of a serialized IPNS record for passed CID
    */
-  getIPNS(libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, options?: GetIPNSOptions): Promise<IPNSRecord>
+  getIPNS(cid: CID, options?: GetIPNSOptions): Promise<Uint8Array<ArrayBuffer>>
 
   /**
-   * Publishes the given {@link IPNSRecord} for the provided {@link MultihashDigest}
+   * Publishes a serialized IPNS record for the passed CID
    */
-  putIPNS(libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, record: IPNSRecord, options?: AbortOptions): Promise<void>
+  putIPNS(cid: CID, record: Uint8Array, options?: AbortOptions): Promise<void>
 
   /**
    * Create the request/response cache used to ensure duplicate requests aren't
@@ -246,3 +237,11 @@ export interface DelegatedRoutingV1HttpApiClient {
 export function delegatedRoutingV1HttpApiClient (init: DelegatedRoutingV1HttpApiClientInit): (components: DelegatedRoutingV1HttpApiClientComponents) => DelegatedRoutingV1HttpApiClient {
   return (components) => new DelegatedRoutingV1HttpApiClientClass(components, init)
 }
+
+export function delegatedRoutingV1HttpApiClientContentRouting (init: DelegatedRoutingV1HttpApiClientInit): (components: DelegatedRoutingV1HttpApiClientComponents) => ContentRouting {
+  return (components) => new DelegatedRoutingV1HttpApiClientContentRouting(delegatedRoutingV1HttpApiClient(init)(components))
+}
+
+export function delegatedRoutingV1HttpApiClientPeerRouting (init: DelegatedRoutingV1HttpApiClientInit): (components: DelegatedRoutingV1HttpApiClientComponents) => PeerRouting {
+  return (components) => new DelegatedRoutingV1HttpApiClientPeerRouting(delegatedRoutingV1HttpApiClient(init)(components))
+}

package/src/routings.ts

@@ -1,14 +1,15 @@
-import { NotFoundError } from '@libp2p/interface'
-import { peerIdFromMultihash } from '@libp2p/peer-id'
-import { marshalIPNSRecord, multihashFromIPNSRoutingKey, unmarshalIPNSRecord } from 'ipns'
+import { contentRoutingSymbol, NotFoundError, peerRoutingSymbol } from '@libp2p/interface'
 import first from 'it-first'
 import map from 'it-map'
 import { digest } from 'multiformats'
 import { CID } from 'multiformats/cid'
+import * as raw from 'multiformats/codecs/raw'
+import * as Digest from 'multiformats/hashes/digest'
+import { identity } from 'multiformats/hashes/identity'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import type { DelegatedRoutingV1HttpApiClient } from './index.js'
-import type { ContentRouting, PeerRouting, AbortOptions, PeerId, PeerInfo, Provider } from '@libp2p/interface'
+import type { DelegatedRoutingV1HttpApiClient } from './index.ts'
+import type { ContentRouting, PeerRouting, AbortOptions, PeerId, PeerInfo, Provider, Startable } from '@libp2p/interface'
 
 const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
 
@@ -19,13 +20,25 @@ function isIPNSKey (key: Uint8Array): boolean {
 /**
  * Wrapper class to convert [http-routing-v1 content events](https://specs.ipfs.tech/routing/http-routing-v1/#response-body) into returned values
  */
-export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRouting {
+export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRouting, Startable {
   private readonly client: DelegatedRoutingV1HttpApiClient
 
   constructor (client: DelegatedRoutingV1HttpApiClient) {
     this.client = client
   }
 
+  get [contentRoutingSymbol] (): ContentRouting {
+    return this
+  }
+
+  async start (): Promise<void> {
+    await this.client.start()
+  }
+
+  async stop (): Promise<void> {
+    await this.client.stop()
+  }
+
   async * findProviders (cid: CID, options: AbortOptions = {}): AsyncIterable<Provider> {
     try {
       yield * map(this.client.getProviders(cid, options), (record) => {
@@ -59,11 +72,10 @@ export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRou
       return
     }
 
-    const digest = multihashFromIPNSRoutingKey(key)
+    const digest = Digest.decode(key.slice(IPNS_PREFIX.length))
     const cid = CID.createV1(0x72, digest)
-    const record = unmarshalIPNSRecord(value)
 
-    await this.client.putIPNS(cid, record, options)
+    await this.client.putIPNS(cid, value, options)
   }
 
   async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
@@ -71,13 +83,11 @@ export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRou
       throw new NotFoundError('Not found')
     }
 
-    const digest = multihashFromIPNSRoutingKey(key)
+    const digest = Digest.decode(key.slice(IPNS_PREFIX.length))
     const cid = CID.createV1(0x72, digest)
 
     try {
-      const record = await this.client.getIPNS(cid, options)
-
-      return marshalIPNSRecord(record)
+      return await this.client.getIPNS(cid, options)
     } catch (err: any) {
       // BadResponseError is thrown when the response had no body, which means
       // the record couldn't be found
@@ -97,15 +107,27 @@ export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRou
 /**
  * Wrapper class to convert [http-routing-v1](https://specs.ipfs.tech/routing/http-routing-v1/#response-body-0) events into expected libp2p values
  */
-export class DelegatedRoutingV1HttpApiClientPeerRouting implements PeerRouting {
+export class DelegatedRoutingV1HttpApiClientPeerRouting implements PeerRouting, Startable {
   private readonly client: DelegatedRoutingV1HttpApiClient
 
   constructor (client: DelegatedRoutingV1HttpApiClient) {
     this.client = client
   }
 
+  get [peerRoutingSymbol] (): PeerRouting {
+    return this
+  }
+
+  async start (): Promise<void> {
+    await this.client.start()
+  }
+
+  async stop (): Promise<void> {
+    await this.client.stop()
+  }
+
   async findPeer (peerId: PeerId, options: AbortOptions = {}): Promise<PeerInfo> {
-    const peer = await first(this.client.getPeers(peerId, options))
+    const peer = await first(this.client.getPeers(peerId.toCID(), options))
 
     if (peer != null) {
       return {
@@ -118,15 +140,19 @@ export class DelegatedRoutingV1HttpApiClientPeerRouting implements PeerRouting {
   }
 
   async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
-    let cidOrPeer: CID | PeerId
+    let cid: CID
 
     try {
-      cidOrPeer = CID.decode(key)
+      cid = CID.decode(key)
     } catch {
-      cidOrPeer = peerIdFromMultihash(digest.decode(key))
+      try {
+        cid = CID.createV1(0x72, digest.decode(key))
+      } catch {
+        cid = CID.createV1(raw.code, identity.digest(key))
+      }
     }
 
-    for await (const peer of this.client.getClosestPeers(cidOrPeer, options)) {
+    for await (const peer of this.client.getClosestPeers(cid, options)) {
       yield {
         id: peer.ID,
         multiaddrs: peer.Addrs ?? []