@helia/ipns 7.2.2 → 7.2.3-2f88fc8

package/src/dnslink.ts

@@ -1,8 +1,10 @@
-import { CodeError, type Logger } from '@libp2p/interface'
+import { } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { RecordType } from '@multiformats/dns'
 import { CID } from 'multiformats/cid'
+import { DNSLinkNotFoundError } from './errors.js'
 import type { ResolveDNSLinkOptions } from './index.js'
+import type { Logger } from '@libp2p/interface'
 import type { Answer, DNS } from '@multiformats/dns'
 
 const MAX_RECURSIVE_DEPTH = 32
@@ -26,7 +28,7 @@ async function recursiveResolveDnslink (domain: string, depth: number, dns: DNS,
   })
 
   // sort the TXT records to ensure deterministic processing
-  const txtRecords = txtRecordsResponse.Answer
+  const txtRecords = (txtRecordsResponse?.Answer ?? [])
     .sort((a, b) => a.data.localeCompare(b.data))
 
   log('found %d TXT records for %s', txtRecords.length, domain)
@@ -98,7 +100,7 @@ async function recursiveResolveDnslink (domain: string, depth: number, dns: DNS,
   })
 
   // sort the CNAME records to ensure deterministic processing
-  const cnameRecords = cnameRecordsResponse.Answer
+  const cnameRecords = (cnameRecordsResponse?.Answer ?? [])
     .sort((a, b) => a.data.localeCompare(b.data))
 
   log('found %d CNAME records for %s', cnameRecords.length, domain)
@@ -111,7 +113,7 @@ async function recursiveResolveDnslink (domain: string, depth: number, dns: DNS,
     }
   }
 
-  throw new CodeError(`No DNSLink records found for domain: ${domain}`, 'ERR_DNSLINK_NOT_FOUND')
+  throw new DNSLinkNotFoundError(`No DNSLink records found for domain: ${domain}`)
 }
 
 async function recursiveResolveDomain (domain: string, depth: number, dns: DNS, log: Logger, options: ResolveDNSLinkOptions = {}): Promise<DNSLinkResult> {
@@ -130,7 +132,7 @@ async function recursiveResolveDomain (domain: string, depth: number, dns: DNS,
     return await recursiveResolveDnslink(domain, depth, dns, log, options)
   } catch (err: any) {
     // If the code is not ENOTFOUND or ERR_DNSLINK_NOT_FOUND or ENODATA then throw the error
-    if (err.code !== 'ENOTFOUND' && err.code !== 'ERR_DNSLINK_NOT_FOUND' && err.code !== 'ENODATA') {
+    if (err.code !== 'ENOTFOUND' && err.code !== 'ENODATA' && err.name !== 'DNSLinkNotFoundError' && err.name !== 'NotFoundError') {
       throw err
     }
 
@@ -144,7 +146,7 @@ async function recursiveResolveDomain (domain: string, depth: number, dns: DNS,
     }
 
     // If this throws then we propagate the error
-    return await recursiveResolveDnslink(domain, depth, dns, log, options)
+    return recursiveResolveDnslink(domain, depth, dns, log, options)
   }
 }
 

package/src/errors.ts

@@ -0,0 +1,53 @@
+export class DNSLinkNotFoundError extends Error {
+  static name = 'DNSLinkNotFoundError'
+
+  constructor (message = 'DNSLink not found') {
+    super(message)
+    this.name = 'DNSLinkNotFoundError'
+  }
+}
+
+export class RecordsFailedValidationError extends Error {
+  static name = 'RecordsFailedValidationError'
+
+  constructor (message = 'Records failed validation') {
+    super(message)
+    this.name = 'RecordsFailedValidationError'
+  }
+}
+
+export class UnsupportedMultibasePrefixError extends Error {
+  static name = 'UnsupportedMultibasePrefixError'
+
+  constructor (message = 'Unsupported multibase prefix') {
+    super(message)
+    this.name = 'UnsupportedMultibasePrefixError'
+  }
+}
+
+export class UnsupportedMultihashCodecError extends Error {
+  static name = 'UnsupportedMultihashCodecError'
+
+  constructor (message = 'Unsupported multihash codec') {
+    super(message)
+    this.name = 'UnsupportedMultihashCodecError'
+  }
+}
+
+export class InvalidValueError extends Error {
+  static name = 'InvalidValueError'
+
+  constructor (message = 'Invalid value') {
+    super(message)
+    this.name = 'InvalidValueError'
+  }
+}
+
+export class InvalidTopicError extends Error {
+  static name = 'InvalidTopicError'
+
+  constructor (message = 'Invalid topic') {
+    super(message)
+    this.name = 'InvalidTopicError'
+  }
+}

package/src/index.ts

@@ -11,23 +11,23 @@
  * import { createHelia } from 'helia'
  * import { ipns } from '@helia/ipns'
  * import { unixfs } from '@helia/unixfs'
+ * import { generateKeyPair } from '@libp2p/crypto/keys'
  *
  * const helia = await createHelia()
  * const name = ipns(helia)
  *
- * // create a public key to publish as an IPNS name
- * const keyInfo = await helia.libp2p.services.keychain.createKey('my-key')
- * const peerId = await helia.libp2p.services.keychain.exportPeerId(keyInfo.name)
+ * // create a keypair to publish an IPNS name
+ * const privateKey = await generateKeyPair('Ed25519')
  *
  * // store some data to publish
  * const fs = unixfs(helia)
- * const cid = await fs.add(Uint8Array.from([0, 1, 2, 3, 4]))
+ * const cid = await fs.addBytes(Uint8Array.from([0, 1, 2, 3, 4]))
  *
  * // publish the name
- * await name.publish(peerId, cid)
+ * await name.publish(privateKey, cid)
  *
  * // resolve the name
- * const result = name.resolve(peerId)
+ * const result = await name.resolve(privateKey.publicKey)
  *
  * console.info(result.cid, result.path)
  * ```
@@ -41,30 +41,29 @@
  * import { createHelia } from 'helia'
  * import { ipns } from '@helia/ipns'
  * import { unixfs } from '@helia/unixfs'
+ * import { generateKeyPair } from '@libp2p/crypto/keys'
  *
  * const helia = await createHelia()
  * const name = ipns(helia)
  *
- * // create a public key to publish as an IPNS name
- * const keyInfo = await helia.libp2p.services.keychain.createKey('my-key')
- * const peerId = await helia.libp2p.services.keychain.exportPeerId(keyInfo.name)
+ * // create a keypair to publish an IPNS name
+ * const privateKey = await generateKeyPair('Ed25519')
  *
  * // store some data to publish
  * const fs = unixfs(helia)
- * const cid = await fs.add(Uint8Array.from([0, 1, 2, 3, 4]))
+ * const cid = await fs.addBytes(Uint8Array.from([0, 1, 2, 3, 4]))
  *
  * // publish the name
- * await name.publish(peerId, cid)
+ * await name.publish(privateKey, cid)
  *
- * // create another public key to re-publish the original record
- * const recursiveKeyInfo = await helia.libp2p.services.keychain.createKey('my-recursive-key')
- * const recursivePeerId = await helia.libp2p.services.keychain.exportPeerId(recursiveKeyInfo.name)
+ * // create another keypair to re-publish the original record
+ * const recursivePrivateKey = await generateKeyPair('Ed25519')
  *
  * // publish the recursive name
- * await name.publish(recursivePeerId, peerId)
+ * await name.publish(recursivePrivateKey, privateKey.publicKey)
  *
  * // resolve the name recursively - it resolves until a CID is found
- * const result = name.resolve(recursivePeerId)
+ * const result = await name.resolve(recursivePrivateKey.publicKey)
  * console.info(result.cid.toString() === cid.toString()) // true
  * ```
  *
@@ -76,27 +75,27 @@
  * import { createHelia } from 'helia'
  * import { ipns } from '@helia/ipns'
  * import { unixfs } from '@helia/unixfs'
+ * import { generateKeyPair } from '@libp2p/crypto/keys'
  *
  * const helia = await createHelia()
  * const name = ipns(helia)
  *
- * // create a public key to publish as an IPNS name
- * const keyInfo = await helia.libp2p.services.keychain.createKey('my-key')
- * const peerId = await helia.libp2p.services.keychain.exportPeerId(keyInfo.name)
+ * // create a keypair to publish an IPNS name
+ * const privateKey = await generateKeyPair('Ed25519')
  *
  * // store some data to publish
  * const fs = unixfs(helia)
- * const fileCid = await fs.add(Uint8Array.from([0, 1, 2, 3, 4]))
+ * const fileCid = await fs.addBytes(Uint8Array.from([0, 1, 2, 3, 4]))
  *
  * // store the file in a directory
- * const dirCid = await fs.mkdir()
+ * const dirCid = await fs.addDirectory()
  * const finalDirCid = await fs.cp(fileCid, dirCid, '/foo.txt')
  *
  * // publish the name
- * await name.publish(peerId, `/ipfs/${finalDirCid}/foo.txt)
+ * await name.publish(privateKey, `/ipfs/${finalDirCid}/foo.txt`)
  *
  * // resolve the name
- * const result = name.resolve(peerId)
+ * const result = await name.resolve(privateKey.publicKey)
  *
  * console.info(result.cid, result.path) // QmFoo.. 'foo.txt'
  * ```
@@ -123,11 +122,14 @@
  * import { pubsub } from '@helia/ipns/routing'
  * import { unixfs } from '@helia/unixfs'
  * import { gossipsub } from '@chainsafe/libp2p-gossipsub'
+ * import { generateKeyPair } from '@libp2p/crypto/keys'
+ * import type { Libp2p, PubSub } from '@libp2p/interface'
+ * import type { DefaultLibp2pServices } from 'helia'
  *
  * const libp2pOptions = libp2pDefaults()
  * libp2pOptions.services.pubsub = gossipsub()
  *
- * const helia = await createHelia({
+ * const helia = await createHelia<Libp2p<DefaultLibp2pServices & { pubsub: PubSub }>>({
  *   libp2p: libp2pOptions
  * })
  * const name = ipns(helia, {
@@ -136,44 +138,50 @@
  *  ]
  * })
  *
- * // create a public key to publish as an IPNS name
- * const keyInfo = await helia.libp2p.services.keychain.createKey('my-key')
- * const peerId = await helia.libp2p.services.keychain.exportPeerId(keyInfo.name)
+ * // create a keypair to publish an IPNS name
+ * const privateKey = await generateKeyPair('Ed25519')
  *
  * // store some data to publish
  * const fs = unixfs(helia)
- * const cid = await fs.add(Uint8Array.from([0, 1, 2, 3, 4]))
+ * const cid = await fs.addBytes(Uint8Array.from([0, 1, 2, 3, 4]))
  *
  * // publish the name
- * await name.publish(peerId, cid)
+ * await name.publish(privateKey, cid)
  *
  * // resolve the name
- * const { cid, path } = name.resolve(peerId)
+ * const result = await name.resolve(privateKey.publicKey)
  * ```
  *
  * @example Using custom DNS over HTTPS resolvers
  *
- * With default {@link DNSResolver} resolvers:
+ * To use custom resolvers, configure Helia's `dns` option:
  *
  * ```TypeScript
  * import { createHelia } from 'helia'
  * import { ipns } from '@helia/ipns'
- * import { unixfs } from '@helia/unixfs'
- * import { dnsOverHttps } from '@helia/ipns/dns-resolvers'
- *
- * const helia = await createHelia()
- * const name = ipns(helia, {
- *  resolvers: [
- *    dnsOverHttps('https://private-dns-server.me/dns-query'),
+ * import { dns } from '@multiformats/dns'
+ * import { dnsOverHttps } from '@multiformats/dns/resolvers'
+ * import { helia } from '@helia/ipns/routing'
+ *
+ * const node = await createHelia({
+ *   dns: dns({
+ *     resolvers: {
+ *       '.': dnsOverHttps('https://private-dns-server.me/dns-query')
+ *     }
+ *   })
+ * })
+ * const name = ipns(node, {
+ *  routers: [
+ *    helia(node.routing)
  *  ]
  * })
  *
- * const { cid, path } = name.resolveDns('some-domain-with-dnslink-entry.com')
+ * const result = name.resolveDNSLink('some-domain-with-dnslink-entry.com')
  * ```
  *
  * @example Resolving a domain with a dnslink entry
  *
- * Calling `resolveDns` with the `@helia/ipns` instance:
+ * Calling `resolveDNSLink` with the `@helia/ipns` instance:
  *
  * ```TypeScript
  * // resolve a CID from a TXT record in a DNS zone file, using the default
@@ -185,10 +193,16 @@
  * // ;; ANSWER SECTION:
  * // _dnslink.website.ipfs.io.  60     IN      TXT     "dnslink=/ipfs/QmWebsite"
  *
- * const { cid, path } = name.resolveDns('ipfs.io')
+ * import { createHelia } from 'helia'
+ * import { ipns } from '@helia/ipns'
+ *
+ * const node = await createHelia()
+ * const name = ipns(node)
  *
- * console.info(cid)
- * // QmWebsite
+ * const { answer } = await name.resolveDNSLink('ipfs.io')
+ *
+ * console.info(answer)
+ * // { data: '/ipfs/QmWebsite' }
  * ```
  *
  * @example Using DNS-Over-HTTPS
@@ -200,14 +214,21 @@
  * If this is a concern, use the DNS-JSON-Over-HTTPS resolver instead.
  *
  * ```TypeScript
- * // use DNS-Over-HTTPS
- * import { dnsOverHttps } from '@helia/ipns/dns-resolvers'
- *
- * const { cid, path } = name.resolveDns('ipfs.io', {
- *   resolvers: [
- *     dnsOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
- *   ]
+ * import { createHelia } from 'helia'
+ * import { ipns } from '@helia/ipns'
+ * import { dns } from '@multiformats/dns'
+ * import { dnsOverHttps } from '@multiformats/dns/resolvers'
+ *
+ * const node = await createHelia({
+ *   dns: dns({
+ *     resolvers: {
+ *       '.': dnsOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
+ *     }
+ *   })
  * })
+ * const name = ipns(node)
+ *
+ * const result = await name.resolveDNSLink('ipfs.io')
  * ```
  *
  * @example Using DNS-JSON-Over-HTTPS
@@ -216,34 +237,46 @@
  * result in a smaller browser bundle due to the response being plain JSON.
  *
  * ```TypeScript
- * // use DNS-JSON-Over-HTTPS
- * import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers'
- *
- * const { cid, path } = name.resolveDns('ipfs.io', {
- *   resolvers: [
- *     dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
- *   ]
+ * import { createHelia } from 'helia'
+ * import { ipns } from '@helia/ipns'
+ * import { dns } from '@multiformats/dns'
+ * import { dnsJsonOverHttps } from '@multiformats/dns/resolvers'
+ *
+ * const node = await createHelia({
+ *   dns: dns({
+ *     resolvers: {
+ *       '.': dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
+ *     }
+ *   })
  * })
+ * const name = ipns(node)
+ *
+ * const result = await name.resolveDNSLink('ipfs.io')
  * ```
  */
 
-import { CodeError } from '@libp2p/interface'
+import { NotFoundError, isPublicKey } from '@libp2p/interface'
 import { logger } from '@libp2p/logger'
-import { peerIdFromString } from '@libp2p/peer-id'
-import { create, marshal, peerIdToRoutingKey, unmarshal } from 'ipns'
+import { createIPNSRecord, marshalIPNSRecord, multihashToIPNSRoutingKey, unmarshalIPNSRecord, type IPNSRecord } from 'ipns'
 import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
+import { base36 } from 'multiformats/bases/base36'
+import { base58btc } from 'multiformats/bases/base58'
 import { CID } from 'multiformats/cid'
+import * as Digest from 'multiformats/hashes/digest'
 import { CustomProgressEvent } from 'progress-events'
 import { resolveDNSLink } from './dnslink.js'
+import { InvalidValueError, RecordsFailedValidationError, UnsupportedMultibasePrefixError, UnsupportedMultihashCodecError } from './errors.js'
 import { helia } from './routing/helia.js'
 import { localStore, type LocalStore } from './routing/local-store.js'
+import { isCodec, IDENTITY_CODEC, SHA2_256_CODEC } from './utils.js'
 import type { IPNSRouting, IPNSRoutingEvents } from './routing/index.js'
 import type { Routing } from '@helia/interface'
-import type { AbortOptions, ComponentLogger, Logger, PeerId } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger, Logger, PrivateKey, PublicKey } from '@libp2p/interface'
 import type { Answer, DNS, ResolveDnsProgressEvents } from '@multiformats/dns'
 import type { Datastore } from 'interface-datastore'
-import type { IPNSRecord } from 'ipns'
+import type { MultibaseDecoder } from 'multiformats/bases/interface'
+import type { MultihashDigest } from 'multiformats/hashes/interface'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
 const log = logger('helia:ipns')
@@ -375,13 +408,13 @@ export interface IPNS {
    *
    * If the value is a PeerId, a recursive IPNS record will be created.
    */
-  publish(key: PeerId, value: CID | PeerId | string, options?: PublishOptions): Promise<IPNSRecord>
+  publish(key: PrivateKey, value: CID | PublicKey | MultihashDigest<0x00 | 0x12> | string, options?: PublishOptions): Promise<IPNSRecord>
 
   /**
    * Accepts a public key formatted as a libp2p PeerID and resolves the IPNS record
    * corresponding to that public key until a value is found
    */
-  resolve(key: PeerId, options?: ResolveOptions): Promise<IPNSResolveResult>
+  resolve(key: PublicKey | MultihashDigest<0x00 | 0x12>, options?: ResolveOptions): Promise<IPNSResolveResult>
 
   /**
    * Resolve a CID from a dns-link style IPNS record
@@ -403,6 +436,11 @@ export interface IPNSComponents {
   logger: ComponentLogger
 }
 
+const bases: Record<string, MultibaseDecoder<string>> = {
+  [base36.prefix]: base36,
+  [base58btc.prefix]: base58btc
+}
+
 class DefaultIPNS implements IPNS {
   private readonly routers: IPNSRouting[]
   private readonly localStore: LocalStore
@@ -420,21 +458,21 @@ class DefaultIPNS implements IPNS {
     this.log = components.logger.forComponent('helia:ipns')
   }
 
-  async publish (key: PeerId, value: CID | PeerId | string, options: PublishOptions = {}): Promise<IPNSRecord> {
+  async publish (key: PrivateKey, value: CID | PublicKey | MultihashDigest<0x00 | 0x12> | string, options: PublishOptions = {}): Promise<IPNSRecord> {
     try {
       let sequenceNumber = 1n
-      const routingKey = peerIdToRoutingKey(key)
+      const routingKey = multihashToIPNSRoutingKey(key.publicKey.toMultihash())
 
       if (await this.localStore.has(routingKey, options)) {
         // if we have published under this key before, increment the sequence number
         const { record } = await this.localStore.get(routingKey, options)
-        const existingRecord = unmarshal(record)
+        const existingRecord = unmarshalIPNSRecord(record)
         sequenceNumber = existingRecord.sequence + 1n
       }
 
       // create record
-      const record = await create(key, value, sequenceNumber, options.lifetime ?? DEFAULT_LIFETIME_MS, options)
-      const marshaledRecord = marshal(record)
+      const record = await createIPNSRecord(key, value, sequenceNumber, options.lifetime ?? DEFAULT_LIFETIME_MS, options)
+      const marshaledRecord = marshalIPNSRecord(record)
 
       await this.localStore.put(routingKey, marshaledRecord, options)
 
@@ -450,8 +488,9 @@ class DefaultIPNS implements IPNS {
     }
   }
 
-  async resolve (key: PeerId, options: ResolveOptions = {}): Promise<IPNSResolveResult> {
-    const routingKey = peerIdToRoutingKey(key)
+  async resolve (key: PublicKey | MultihashDigest<0x00 | 0x12>, options: ResolveOptions = {}): Promise<IPNSResolveResult> {
+    const digest = isPublicKey(key) ? key.toMultihash() : key
+    const routingKey = multihashToIPNSRoutingKey(digest)
     const record = await this.#findIpnsRecord(routingKey, options)
 
     return {
@@ -511,7 +550,31 @@ class DefaultIPNS implements IPNS {
       const scheme = parts[1]
 
       if (scheme === 'ipns') {
-        const { cid } = await this.resolve(peerIdFromString(parts[2]), options)
+        const str = parts[2]
+        const prefix = str.substring(0, 1)
+        let buf: Uint8Array | undefined
+
+        if (prefix === '1' || prefix === 'Q') {
+          buf = base58btc.decode(`z${str}`)
+        } else if (bases[prefix] != null) {
+          buf = bases[prefix].decode(str)
+        } else {
+          throw new UnsupportedMultibasePrefixError(`Unsupported multibase prefix "${prefix}"`)
+        }
+
+        let digest: MultihashDigest<number>
+
+        try {
+          digest = Digest.decode(buf)
+        } catch {
+          digest = CID.decode(buf).multihash
+        }
+
+        if (!isCodec(digest, IDENTITY_CODEC) && !isCodec(digest, SHA2_256_CODEC)) {
+          throw new UnsupportedMultihashCodecError(`Unsupported multihash codec "${digest.code}"`)
+        }
+
+        const { cid } = await this.resolve(digest, options)
         const path = parts.slice(3).join('/')
         return {
           cid,
@@ -530,7 +593,7 @@ class DefaultIPNS implements IPNS {
     }
 
     log.error('invalid ipfs path %s', ipfsPath)
-    throw new Error('Invalid value')
+    throw new InvalidValueError('Invalid value')
   }
 
   async #findIpnsRecord (routingKey: Uint8Array, options: ResolveOptions = {}): Promise<IPNSRecord> {
@@ -553,7 +616,7 @@ class DefaultIPNS implements IPNS {
           this.log('record was valid')
 
           // check the TTL
-          const ipnsRecord = unmarshal(record)
+          const ipnsRecord = unmarshalIPNSRecord(record)
 
           // IPNS TTL is in nanoseconds, convert to milliseconds, default to one
           // hour
@@ -588,7 +651,7 @@ class DefaultIPNS implements IPNS {
     }
 
     if (options.offline === true) {
-      throw new CodeError('Record was not present in the cache or has expired', 'ERR_NOT_FOUND')
+      throw new NotFoundError('Record was not present in the cache or has expired')
     }
 
     log('did not have record locally')
@@ -624,17 +687,17 @@ class DefaultIPNS implements IPNS {
 
     if (records.length === 0) {
       if (foundInvalid > 0) {
-        throw new CodeError(`${foundInvalid > 1 ? `${foundInvalid} records` : 'Record'} found for routing key ${foundInvalid > 1 ? 'were' : 'was'} invalid`, 'ERR_RECORDS_FAILED_VALIDATION')
+        throw new RecordsFailedValidationError(`${foundInvalid > 1 ? `${foundInvalid} records` : 'Record'} found for routing key ${foundInvalid > 1 ? 'were' : 'was'} invalid`)
       }
 
-      throw new CodeError('Could not find record for routing key', 'ERR_NOT_FOUND')
+      throw new NotFoundError('Could not find record for routing key')
     }
 
     const record = records[ipnsSelector(routingKey, records)]
 
     await this.localStore.put(routingKey, record, options)
 
-    return unmarshal(record)
+    return unmarshalIPNSRecord(record)
   }
 }
 

package/src/routing/index.ts

@@ -22,6 +22,10 @@ export interface IPNSRouting {
   get(routingKey: Uint8Array, options?: GetOptions): Promise<Uint8Array>
 }
 
+export type { DatastoreProgressEvents }
+export type { HeliaRoutingProgressEvents }
+export type { PubSubProgressEvents }
+
 export type IPNSRoutingEvents =
   DatastoreProgressEvents |
   HeliaRoutingProgressEvents |
@@ -29,3 +33,4 @@ export type IPNSRoutingEvents =
 
 export { helia } from './helia.js'
 export { pubsub } from './pubsub.js'
+export type { PubsubRoutingComponents } from './pubsub.js'

package/src/routing/local-store.ts

@@ -48,7 +48,7 @@ export function localStore (datastore: Datastore): LocalStore {
             return
           }
         } catch (err: any) {
-          if (err.code !== 'ERR_NOT_FOUND') {
+          if (err.name !== 'NotFoundError') {
             throw err
           }
         }

package/src/routing/pubsub.ts

@@ -1,16 +1,18 @@
-import { CodeError } from '@libp2p/interface'
+import { isPublicKey } from '@libp2p/interface'
 import { logger } from '@libp2p/logger'
-import { peerIdToRoutingKey } from 'ipns'
+import { multihashToIPNSRoutingKey } from 'ipns'
 import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
 import { CustomProgressEvent, type ProgressEvent } from 'progress-events'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { InvalidTopicError } from '../errors.js'
 import { localStore, type LocalStore } from './local-store.js'
 import type { GetOptions, IPNSRouting, PutOptions } from './index.js'
-import type { PeerId, Message, PublishResult, PubSub } from '@libp2p/interface'
+import type { PeerId, Message, PublishResult, PubSub, PublicKey } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
+import type { MultihashDigest } from 'multiformats/hashes/interface'
 
 const log = logger('helia:ipns:routing:pubsub')
 
@@ -147,8 +149,9 @@ class PubSubRouting implements IPNSRouting {
   /**
    * Cancel pubsub subscriptions related to ipns
    */
-  cancel (key: PeerId): void {
-    const routingKey = peerIdToRoutingKey(key)
+  cancel (key: PublicKey | MultihashDigest<0x00 | 0x12>): void {
+    const digest = isPublicKey(key) ? key.toMultihash() : key
+    const routingKey = multihashToIPNSRoutingKey(digest)
     const topic = keyToTopic(routingKey)
 
     // Not found topic
@@ -177,7 +180,7 @@ function keyToTopic (key: Uint8Array): string {
  */
 function topicToKey (topic: string): Uint8Array {
   if (topic.substring(0, PUBSUB_NAMESPACE.length) !== PUBSUB_NAMESPACE) {
-    throw new CodeError('topic received is not from a record', 'ERR_TOPIC_IS_NOT_FROM_RECORD_NAMESPACE')
+    throw new InvalidTopicError('Topic received is not from a record')
   }
 
   const key = topic.substring(PUBSUB_NAMESPACE.length)

package/src/utils.ts

@@ -0,0 +1,8 @@
+import type { MultihashDigest } from 'multiformats/hashes/interface'
+
+export const IDENTITY_CODEC = 0x0
+export const SHA2_256_CODEC = 0x12
+
+export function isCodec <T extends number> (digest: MultihashDigest, codec: T): digest is MultihashDigest<T> {
+  return digest.code === codec
+}