@helia/ipns 9.2.1-6f8165b5 → 9.2.1-73a28eda

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,81 +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
-    // @ts-expect-error @libp2p/peer-id needs new multiformats
-    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) {
@@ -122,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
@@ -156,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)
@@ -177,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
           })
@@ -192,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) {
@@ -213,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;
+}

package/src/pb/ipns.ts

@@ -0,0 +1,280 @@
+import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime'
+import type { Codec, DecodeOptions } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface IpnsEntry {
+  value?: Uint8Array
+  signatureV1?: Uint8Array
+  validityType?: IpnsEntry.ValidityType
+  validity?: Uint8Array
+  sequence?: bigint
+  ttl?: bigint
+  publicKey?: Uint8Array
+  signatureV2?: Uint8Array
+  data?: Uint8Array
+}
+
+export namespace IpnsEntry {
+  export enum ValidityType {
+    EOL = 'EOL'
+  }
+
+  enum __ValidityTypeValues {
+    EOL = 0
+  }
+
+  export namespace ValidityType {
+    export const codec = (): Codec<ValidityType> => {
+      return enumeration<ValidityType>(__ValidityTypeValues)
+    }
+  }
+
+  let _codec: Codec<IpnsEntry>
+
+  export const codec = (): Codec<IpnsEntry> => {
+    if (_codec == null) {
+      _codec = message<IpnsEntry>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.value != null) {
+          w.uint32(10)
+          w.bytes(obj.value)
+        }
+
+        if (obj.signatureV1 != null) {
+          w.uint32(18)
+          w.bytes(obj.signatureV1)
+        }
+
+        if (obj.validityType != null) {
+          w.uint32(24)
+          IpnsEntry.ValidityType.codec().encode(obj.validityType, w)
+        }
+
+        if (obj.validity != null) {
+          w.uint32(34)
+          w.bytes(obj.validity)
+        }
+
+        if (obj.sequence != null) {
+          w.uint32(40)
+          w.uint64(obj.sequence)
+        }
+
+        if (obj.ttl != null) {
+          w.uint32(48)
+          w.uint64(obj.ttl)
+        }
+
+        if (obj.publicKey != null) {
+          w.uint32(58)
+          w.bytes(obj.publicKey)
+        }
+
+        if (obj.signatureV2 != null) {
+          w.uint32(66)
+          w.bytes(obj.signatureV2)
+        }
+
+        if (obj.data != null) {
+          w.uint32(74)
+          w.bytes(obj.data)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length, opts = {}) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              obj.value = reader.bytes()
+              break
+            }
+            case 2: {
+              obj.signatureV1 = reader.bytes()
+              break
+            }
+            case 3: {
+              obj.validityType = IpnsEntry.ValidityType.codec().decode(reader)
+              break
+            }
+            case 4: {
+              obj.validity = reader.bytes()
+              break
+            }
+            case 5: {
+              obj.sequence = reader.uint64()
+              break
+            }
+            case 6: {
+              obj.ttl = reader.uint64()
+              break
+            }
+            case 7: {
+              obj.publicKey = reader.bytes()
+              break
+            }
+            case 8: {
+              obj.signatureV2 = reader.bytes()
+              break
+            }
+            case 9: {
+              obj.data = reader.bytes()
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+
+        return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.value`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.signatureV1`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 3: {
+              yield {
+                field: `${prefix}.validityType`,
+                value: IpnsEntry.ValidityType.codec().decode(reader)
+              }
+              break
+            }
+            case 4: {
+              yield {
+                field: `${prefix}.validity`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 5: {
+              yield {
+                field: `${prefix}.sequence`,
+                value: reader.uint64()
+              }
+              break
+            }
+            case 6: {
+              yield {
+                field: `${prefix}.ttl`,
+                value: reader.uint64()
+              }
+              break
+            }
+            case 7: {
+              yield {
+                field: `${prefix}.publicKey`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 8: {
+              yield {
+                field: `${prefix}.signatureV2`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 9: {
+              yield {
+                field: `${prefix}.data`,
+                value: reader.bytes()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+      })
+    }
+
+    return _codec
+  }
+
+  export interface IpnsEntryValueFieldEvent {
+    field: '$.value'
+    value: Uint8Array
+  }
+
+  export interface IpnsEntrySignatureV1FieldEvent {
+    field: '$.signatureV1'
+    value: Uint8Array
+  }
+
+  export interface IpnsEntryValidityTypeFieldEvent {
+    field: '$.validityType'
+    value: IpnsEntry.ValidityType
+  }
+
+  export interface IpnsEntryValidityFieldEvent {
+    field: '$.validity'
+    value: Uint8Array
+  }
+
+  export interface IpnsEntrySequenceFieldEvent {
+    field: '$.sequence'
+    value: bigint
+  }
+
+  export interface IpnsEntryTtlFieldEvent {
+    field: '$.ttl'
+    value: bigint
+  }
+
+  export interface IpnsEntryPublicKeyFieldEvent {
+    field: '$.publicKey'
+    value: Uint8Array
+  }
+
+  export interface IpnsEntrySignatureV2FieldEvent {
+    field: '$.signatureV2'
+    value: Uint8Array
+  }
+
+  export interface IpnsEntryDataFieldEvent {
+    field: '$.data'
+    value: Uint8Array
+  }
+
+  export function encode (obj: Partial<IpnsEntry>): Uint8Array<ArrayBuffer> {
+    return encodeMessage(obj, IpnsEntry.codec())
+  }
+
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<IpnsEntry>): IpnsEntry {
+    return decodeMessage(buf, IpnsEntry.codec(), opts)
+  }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<IpnsEntry>): Generator<IpnsEntryValueFieldEvent | IpnsEntrySignatureV1FieldEvent | IpnsEntryValidityTypeFieldEvent | IpnsEntryValidityFieldEvent | IpnsEntrySequenceFieldEvent | IpnsEntryTtlFieldEvent | IpnsEntryPublicKeyFieldEvent | IpnsEntrySignatureV2FieldEvent | IpnsEntryDataFieldEvent> {
+    return streamMessage(buf, IpnsEntry.codec(), opts)
+  }
+}