@helia/ipns 9.2.1-eb1908b3 → 9.2.1-ed6c3b79

package/src/ipns/republisher.ts

@@ -1,17 +1,18 @@
 import { Queue, repeatingTask } from '@libp2p/utils'
-import { createIPNSRecord, marshalIPNSRecord, unmarshalIPNSRecord } from 'ipns'
 import { DEFAULT_REPUBLISH_CONCURRENCY, DEFAULT_REPUBLISH_INTERVAL_MS, DEFAULT_TTL_NS } from '../constants.ts'
+import { createIPNSRecord } from '../records.ts'
+import { marshalIPNSRecord, unmarshalIPNSRecord } from '../utils.ts'
 import { shouldRepublish } from '../utils.ts'
+import type { IPNSRecord } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
-import type { AbortOptions, ComponentLogger, Libp2p, Logger, PrivateKey } from '@libp2p/interface'
-import type { Keychain } from '@libp2p/keychain'
+import type { Keychain, PrivateKey } from '@helia/interface'
+import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { RepeatingTask } from '@libp2p/utils'
-import type { IPNSRecord } from 'ipns'
 
 export interface IPNSRepublisherComponents {
   logger: ComponentLogger
-  libp2p: Libp2p<{ keychain: Keychain }>
+  keychain: Keychain
 }
 
 export interface IPNSRepublisherInit {
@@ -33,9 +34,9 @@ export class IPNSRepublisher {
   constructor (components: IPNSRepublisherComponents, init: IPNSRepublisherInit) {
     this.log = components.logger.forComponent('helia:ipns')
     this.localStore = init.localStore
-    this.keychain = components.libp2p.services.keychain
+    this.keychain = components.keychain
     this.republishConcurrency = init.republishConcurrency || DEFAULT_REPUBLISH_CONCURRENCY
-    this.started = components.libp2p.status === 'started'
+    this.started = false
     this.routers = init.routers ?? []
 
     this.republishTask = repeatingTask(this.#republish.bind(this), init.republishInterval ?? DEFAULT_REPUBLISH_INTERVAL_MS, {
@@ -78,18 +79,21 @@ export class IPNSRepublisher {
 
     try {
       const recordsToRepublish: Array<{ routingKey: Uint8Array, record: IPNSRecord }> = []
+      let listed = 0
 
       // Find all records using the localStore.list method
       for await (const { routingKey, record, metadata, created } of this.localStore.list(options)) {
+        listed++
+
         if (metadata == null) {
           // Skip if no metadata is found from before we started
           // storing metadata or for records republished without a key
-          this.log(`no metadata found for record ${routingKey.toString()}, skipping`)
+          this.log('no metadata found for record %b, skipping', routingKey)
           continue
         }
         let ipnsRecord: IPNSRecord
         try {
-          ipnsRecord = unmarshalIPNSRecord(record)
+          ipnsRecord = await unmarshalIPNSRecord(routingKey, record, this.keychain, options)
         } catch (err: any) {
           this.log.error('error unmarshaling record - %e', err)
           continue
@@ -97,7 +101,7 @@ export class IPNSRepublisher {
 
         // Only republish records that are within the DHT or record expiry threshold
         if (!shouldRepublish(ipnsRecord, created)) {
-          this.log.trace(`skipping record ${routingKey.toString()}within republish threshold`)
+          this.log.trace('skipping record %b within republish threshold', routingKey)
           continue
         }
         const sequenceNumber = ipnsRecord.sequence + 1n
@@ -110,16 +114,23 @@ export class IPNSRepublisher {
           this.log.error('missing key %s, skipping republishing record - %e', metadata.keyName, err)
           continue
         }
+
         try {
-          const updatedRecord = await createIPNSRecord(privKey, ipnsRecord.value, sequenceNumber, metadata.lifetime, { ...options, ttlNs })
-          recordsToRepublish.push({ routingKey, record: updatedRecord })
+          const updatedRecord = await createIPNSRecord(privKey, ipnsRecord.value, sequenceNumber, metadata.lifetime, {
+            ...options,
+            ttlNs
+          })
+          recordsToRepublish.push({
+            routingKey,
+            record: updatedRecord
+          })
         } catch (err: any) {
           this.log.error('error creating updated IPNS record for %s - %e', routingKey, err)
           continue
         }
       }
 
-      this.log(`found ${recordsToRepublish.length} records to republish`)
+      this.log(`found ${recordsToRepublish.length}/${listed} records to republish`)
 
       // Republish each record
       for (const { routingKey, record } of recordsToRepublish) {

package/src/ipns/resolver.ts

@@ -1,33 +1,21 @@
-import { isPeerId, isPublicKey } from '@libp2p/interface'
-import { multihashToIPNSRoutingKey, unmarshalIPNSRecord } 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 { DEFAULT_TTL_NS } from '../constants.ts'
-import { InvalidValueError, RecordNotFoundError, RecordsFailedValidationError, UnsupportedMultibasePrefixError, UnsupportedMultihashCodecError } from '../errors.ts'
-import { isCodec, IDENTITY_CODEC, SHA2_256_CODEC, isLibp2pCID } from '../utils.ts'
-import type { IPNSResolveResult, ResolveOptions, ResolveResult } from '../index.ts'
+import { RecordNotFoundError, RecordsFailedValidationError } from '../errors.ts'
+import { ipnsSelector } from '../selector.ts'
+import { multihashToIPNSRoutingKey, unmarshalIPNSRecord, normalizeKey, IPNS_STRING_PREFIX } from '../utils.ts'
+import { ipnsValidator } from '../validator.ts'
+import type { IPNSRecord, ResolveOptions, ResolveResult } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
-import type { Routing } from '@helia/interface'
-import type { ComponentLogger, Logger, PeerId, PublicKey } from '@libp2p/interface'
+import type { Routing, Keychain } from '@helia/interface'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 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'
 
-const bases: Record<string, MultibaseDecoder<string>> = {
-  [base36.prefix]: base36,
-  [base58btc.prefix]: base58btc
-}
-
 export interface IPNSResolverComponents {
   datastore: Datastore
   routing: Routing
   logger: ComponentLogger
+  keychain: Keychain
 }
 
 export interface IPNResolverInit {
@@ -39,80 +27,37 @@ export class IPNSResolver {
   public readonly routers: IPNSRouting[]
   private readonly localStore: LocalStore
   private readonly log: Logger
+  private keychain: Keychain
 
   constructor (components: IPNSResolverComponents, init: IPNResolverInit) {
     this.log = components.logger.forComponent('helia:ipns')
     this.localStore = init.localStore
     this.routers = init.routers
+    this.keychain = components.keychain
   }
 
-  async resolve (key: CID<unknown, 0x72, 0x00 | 0x12, 1> | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId, options: ResolveOptions = {}): Promise<IPNSResolveResult> {
-    const digest = isPublicKey(key) || isPeerId(key) ? key.toMultihash() : isLibp2pCID(key) ? key.multihash : key
-    const routingKey = multihashToIPNSRoutingKey(digest)
-    const record = await this.#findIpnsRecord(routingKey, options)
-
-    return {
-      ...(await this.#resolve(record.value, options)),
-      record
-    }
-  }
+  async * resolve (key: MultihashDigest, options: ResolveOptions = {}): AsyncGenerator<ResolveResult> {
+    let { digest } = normalizeKey(key)
 
-  async #resolve (ipfsPath: string, options: ResolveOptions = {}): Promise<ResolveResult> {
-    const parts = ipfsPath.split('/')
-    try {
-      const scheme = parts[1]
-
-      if (scheme === 'ipns') {
-        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}"`)
-        }
+    while (true) {
+      const routingKey = multihashToIPNSRoutingKey(digest)
+      const record = await this.#findIpnsRecord(routingKey, options)
 
-        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,
-          path: path === '' ? undefined : path
-        }
-      } else if (scheme === 'ipfs') {
-        const cid = CID.parse(parts[2])
-        const path = parts.slice(3).join('/')
+      yield {
+        record
+      }
 
-        return {
-          cid,
-          path: path === '' ? undefined : path
-        }
+      if (!record.value.startsWith(IPNS_STRING_PREFIX)) {
+        // not a recursive record
+        break
       }
-    } catch (err) {
-      this.log.error('error parsing ipfs path - %e', err)
-    }
 
-    this.log.error('invalid ipfs path %s', ipfsPath)
-    throw new InvalidValueError('Invalid value')
+      ({ digest } = normalizeKey(record.value))
+    }
   }
 
   async #findIpnsRecord (routingKey: Uint8Array, options: ResolveOptions = {}): Promise<IPNSRecord> {
-    const records: Uint8Array[] = []
+    const records: IPNSRecord[] = []
     const cached = await this.localStore.has(routingKey, options)
 
     if (cached) {
@@ -121,17 +66,19 @@ export class IPNSResolver {
       if (options.nocache !== true) {
         try {
           // check the local cache first
-          const { record, created } = await this.localStore.get(routingKey, options)
+          const { record: marshaledIPNSRecord, created } = await this.localStore.get(routingKey, options)
 
           this.log('record retrieved from cache')
 
+          // unmarshal the record
+          const ipnsRecord = await unmarshalIPNSRecord(routingKey, marshaledIPNSRecord, this.keychain, options)
+
           // validate the record
-          await ipnsValidator(routingKey, record)
+          await ipnsValidator(ipnsRecord, options)
 
           this.log('record was valid')
 
           // check the TTL
-          const ipnsRecord = unmarshalIPNSRecord(record)
 
           // IPNS TTL is in nanoseconds, convert to milliseconds, default to one
           // hour
@@ -155,7 +102,7 @@ export class IPNSResolver {
           // add the local record to our list of resolved record, and also
           // search the routing for updates - the most up to date record will be
           // returned
-          records.push(record)
+          records.push(ipnsRecord)
         } catch (err) {
           this.log('cached record was invalid - %e', err)
           await this.localStore.delete(routingKey, options)
@@ -176,10 +123,10 @@ export class IPNSResolver {
 
     await Promise.all(
       this.routers.map(async (router) => {
-        let record: Uint8Array
+        let marshaledIPNSRecord: Uint8Array
 
         try {
-          record = await router.get(routingKey, {
+          marshaledIPNSRecord = await router.get(routingKey, {
             ...options,
             validate: false
           })
@@ -191,7 +138,12 @@ export class IPNSResolver {
         }
 
         try {
-          await ipnsValidator(routingKey, record)
+          // unmarshal ensures that (1) SignatureV2 and Data are present, (2) that ValidityType
+          // and Validity are of valid types and have a value, (3) that CBOR data matches protobuf
+          // if it's a V1+V2 record
+          const record = await unmarshalIPNSRecord(routingKey, marshaledIPNSRecord, this.keychain, options)
+
+          await ipnsValidator(record, options)
 
           records.push(record)
         } catch (err) {
@@ -212,8 +164,8 @@ export class IPNSResolver {
 
     const record = records[ipnsSelector(routingKey, records)]
 
-    await this.localStore.put(routingKey, record, options)
+    await this.localStore.put(routingKey, record.bytes, options)
 
-    return unmarshalIPNSRecord(record)
+    return record
   }
 }

package/src/ipns.ts

@@ -5,10 +5,15 @@ import { IPNSResolver } from './ipns/resolver.ts'
 import { localStore } from './local-store.ts'
 import { helia } from './routing/helia.ts'
 import { localStoreRouting } from './routing/local-store.ts'
-import type { IPNSComponents, IPNS as IPNSInterface, IPNSOptions, IPNSPublishResult, IPNSResolveResult, PublishOptions, ResolveOptions } from './index.ts'
+import { ipnsSelector } from './selector.ts'
+import { normalizeKey, normalizeValue, unmarshalIPNSRecord } from './utils.ts'
+import { ipnsValidator } from './validator.ts'
+import type { IPNSComponents, IPNS as IPNSInterface, IPNSOptions, PublishResult, PublishOptions, ResolveOptions, ResolveResult } from './index.ts'
 import type { LocalStore } from './local-store.ts'
 import type { IPNSRouting } from './routing/index.ts'
-import type { AbortOptions, PeerId, PublicKey, Startable } from '@libp2p/interface'
+import type { PublicKey } from '@helia/interface'
+import type { AbortOptions, Libp2p, Startable } from '@libp2p/interface'
+import type { ValidateFn, SelectFn } from '@libp2p/kad-dht'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 
 export class IPNS implements IPNSInterface, Startable {
@@ -17,11 +22,13 @@ export class IPNS implements IPNSInterface, Startable {
   private readonly republisher: IPNSRepublisher
   private readonly resolver: IPNSResolver
   private readonly localStore: LocalStore
+  private readonly components: IPNSComponents
   private started: boolean
 
   constructor (components: IPNSComponents, init: IPNSOptions = {}) {
     this.localStore = localStore(components.datastore, components.logger.forComponent('helia:ipns:local-store'))
-    this.started = components.libp2p.status === 'started'
+    this.components = components
+    this.started = false
 
     this.routers = [
       localStoreRouting(this.localStore),
@@ -53,6 +60,26 @@ export class IPNS implements IPNSInterface, Startable {
     if (this.started) {
       this.republisher.start()
     }
+
+    for (const component of Object.values(this.components)) {
+      if (isLibp2p(component)) {
+        for (const service of Object.values(component.services)) {
+          if (isKadDHT(service)) {
+            // @ ts-expect-error https://github.com/libp2p/js-libp2p/pull/3506
+            service.selectors.ipns = async (key: Uint8Array, values: Uint8Array[]): Promise<number> => {
+              const records = await Promise.all(values.map(buf => unmarshalIPNSRecord(key, buf, this.components.keychain)))
+
+              return ipnsSelector(key, records)
+            }
+
+            service.validators.ipns = async (key: Uint8Array, value: Uint8Array): Promise<void> => {
+              const record = await unmarshalIPNSRecord(key, value, this.components.keychain)
+              await ipnsValidator(record)
+            }
+          }
+        }
+      }
+    }
   }
 
   start (): void {
@@ -73,15 +100,25 @@ export class IPNS implements IPNSInterface, Startable {
     this.republisher.stop()
   }
 
-  async publish (keyName: string, value: CID | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId | string, options: PublishOptions = {}): Promise<IPNSPublishResult> {
-    return this.publisher.publish(keyName, value, options)
+  async publish (keyName: string, value: PublicKey | CID | MultihashDigest | string, options: PublishOptions = {}): Promise<PublishResult> {
+    return this.publisher.publish(keyName, normalizeValue(value), options)
   }
 
-  async resolve (key: CID<unknown, 0x72, 0x00 | 0x12, 1> | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId, options: ResolveOptions = {}): Promise<IPNSResolveResult> {
-    return this.resolver.resolve(key, options)
+  async * resolve (key: PublicKey | CID<unknown, 0x72> | MultihashDigest | string, options: ResolveOptions = {}): AsyncGenerator<ResolveResult> {
+    const { digest } = normalizeKey(key)
+
+    yield * this.resolver.resolve(digest, options)
   }
 
   async unpublish (keyName: string, options?: AbortOptions): Promise<void> {
     return this.publisher.unpublish(keyName, options)
   }
 }
+
+function isLibp2p (obj?: any): obj is Libp2p {
+  return obj?.services != null
+}
+
+function isKadDHT (obj?: any): obj is { validators: Record<string, ValidateFn>, selectors: Record<string, SelectFn> } {
+  return obj?.validators != null && obj?.selectors != null
+}

package/src/pb/ipns.proto

@@ -0,0 +1,39 @@
+// https://github.com/ipfs/boxo/blob/main/ipns/pb/record.proto
+
+syntax = "proto3";
+
+message IpnsEntry {
+	enum ValidityType {
+		// setting an EOL says "this record is valid until..."
+		EOL = 0;
+	}
+
+	// legacy V1 copy of data[Value]
+	optional bytes value = 1;
+
+	// legacy V1 field, verify 'signatureV2' instead
+	optional bytes signatureV1 = 2;
+
+	// legacy V1 copies of data[ValidityType] and data[Validity]
+	optional ValidityType validityType = 3;
+	optional bytes validity = 4;
+
+	// legacy V1 copy of data[Sequence]
+	optional uint64 sequence = 5;
+
+	// legacy V1 copy copy of data[TTL]
+	optional uint64 ttl = 6;
+
+	// Optional Public Key to be used for signature verification.
+	// Used for big keys such as old RSA keys. Including the public key as part of
+	// the record itself makes it verifiable in offline mode, without any additional lookup.
+	// For newer Ed25519 keys, the public key is small enough that it can be embedded in the
+	// IPNS Name itself, making this field unnecessary.
+	optional bytes publicKey = 7;
+
+	// (mandatory V2) signature of the IPNS record
+	optional bytes signatureV2 = 8;
+
+	// (mandatory V2) extensible record data in DAG-CBOR format
+	optional bytes data = 9;
+}