@helia/ipns 10.0.0 → 10.0.1-883ff053

package/src/ipns/resolver.ts

@@ -1,9 +1,11 @@
+import { base36 } from 'multiformats/bases/base36'
 import { DEFAULT_TTL_NS } from '../constants.ts'
-import { RecordNotFoundError, RecordsFailedValidationError } from '../errors.ts'
+import { InvalidValueError, RecordNotFoundError, RecordsFailedValidationError } from '../errors.ts'
+import { IPNSEntry } from '../pb/ipns.ts'
 import { ipnsSelector } from '../selector.ts'
-import { multihashToIPNSRoutingKey, unmarshalIPNSRecord, normalizeKey, IPNS_STRING_PREFIX } from '../utils.ts'
+import { multihashToIPNSRoutingKey, normalizeKey, IPNS_STRING_PREFIX, ipnsRecordValueToString, decodeExtensibleData } from '../utils.ts'
 import { ipnsValidator } from '../validator.ts'
-import type { IPNSRecord, ResolveOptions, ResolveResult } from '../index.ts'
+import type { IPNSResolveOptions, IPNSResolveResult } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
 import type { Routing, Keychain } from '@helia/interface'
@@ -36,28 +38,39 @@ export class IPNSResolver {
     this.keychain = components.keychain
   }
 
-  async * resolve (key: MultihashDigest, options: ResolveOptions = {}): AsyncGenerator<ResolveResult> {
+  async * resolve (key: MultihashDigest, options: IPNSResolveOptions = {}): AsyncGenerator<IPNSResolveResult> {
     let { digest } = normalizeKey(key)
 
     while (true) {
       const routingKey = multihashToIPNSRoutingKey(digest)
       const record = await this.#findIpnsRecord(routingKey, options)
+      let value = ''
+
+      if (record.data != null) {
+        const data = decodeExtensibleData(record.data)
+        value = ipnsRecordValueToString(data.Value)
+      } else if (record.value != null) {
+        value = ipnsRecordValueToString(record.value)
+      } else {
+        throw new InvalidValueError(`Record for key ${base36.encode(digest.bytes)} contained no value`)
+      }
 
       yield {
-        record
+        record,
+        value
       }
 
-      if (!record.value.startsWith(IPNS_STRING_PREFIX)) {
+      if (!value.startsWith(IPNS_STRING_PREFIX)) {
         // not a recursive record
         break
       }
 
-      ({ digest } = normalizeKey(record.value))
+      ({ digest } = normalizeKey(value))
     }
   }
 
-  async #findIpnsRecord (routingKey: Uint8Array, options: ResolveOptions = {}): Promise<IPNSRecord> {
-    const records: IPNSRecord[] = []
+  async #findIpnsRecord (routingKey: Uint8Array, options: IPNSResolveOptions = {}): Promise<IPNSEntry> {
+    const records: IPNSEntry[] = []
     const cached = await this.localStore.has(routingKey, options)
 
     if (cached) {
@@ -70,19 +83,23 @@ export class IPNSResolver {
 
           this.log('record retrieved from cache')
 
-          // unmarshal the record
-          const ipnsRecord = await unmarshalIPNSRecord(routingKey, marshaledIPNSRecord, this.keychain, options)
+          // unmarshal and validate the record
+          let ipnsRecord: IPNSEntry
 
-          // validate the record
-          await ipnsValidator(ipnsRecord, options)
-
-          this.log('record was valid')
+          if (options.validate === false) {
+            ipnsRecord = IPNSEntry.decode(marshaledIPNSRecord)
+            this.log('skipped validation of record')
+          } else {
+            ipnsRecord = await ipnsValidator(routingKey, marshaledIPNSRecord, this.keychain, options)
+            this.log('record was valid')
+          }
 
           // check the TTL
+          const data = decodeExtensibleData(ipnsRecord.data)
 
           // IPNS TTL is in nanoseconds, convert to milliseconds, default to one
           // hour
-          const ttlMs = Number((ipnsRecord.ttl ?? DEFAULT_TTL_NS) / 1_000_000n)
+          const ttlMs = Number((data.TTL ?? DEFAULT_TTL_NS) / 1_000_000n)
           const ttlExpires = created.getTime() + ttlMs
 
           if (ttlExpires > Date.now()) {
@@ -138,12 +155,13 @@ export class IPNSResolver {
         }
 
         try {
-          // 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)
+          let record: IPNSEntry
 
-          await ipnsValidator(record, options)
+          if (options.validate === false) {
+            record = IPNSEntry.decode(marshaledIPNSRecord)
+          } else {
+            record = await ipnsValidator(routingKey, marshaledIPNSRecord, this.keychain, options)
+          }
 
           records.push(record)
         } catch (err) {
@@ -164,7 +182,7 @@ export class IPNSResolver {
 
     const record = records[ipnsSelector(routingKey, records)]
 
-    await this.localStore.put(routingKey, record.bytes, options)
+    await this.localStore.put(routingKey, IPNSEntry.encode(record), options)
 
     return record
   }

package/src/ipns.ts

@@ -1,14 +1,15 @@
 import { CID } from 'multiformats/cid'
+import { IPNSEntry } from './index.ts'
 import { IPNSPublisher } from './ipns/publisher.ts'
 import { IPNSRepublisher } from './ipns/republisher.ts'
 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 { heliaIPNSRouting } from './routing/helia.ts'
+import { localStoreIPNSRouting } from './routing/local-store.ts'
 import { ipnsSelector } from './selector.ts'
-import { normalizeKey, normalizeValue, unmarshalIPNSRecord } from './utils.ts'
+import { normalizeKey, normalizeValue } from './utils.ts'
 import { ipnsValidator } from './validator.ts'
-import type { IPNSComponents, IPNS as IPNSInterface, IPNSOptions, PublishResult, PublishOptions, ResolveOptions, ResolveResult } from './index.ts'
+import type { IPNSComponents, IPNS as IPNSInterface, IPNSOptions, IPNSPublishResult, PublishOptions, IPNSResolveOptions, IPNSResolveResult } from './index.ts'
 import type { LocalStore } from './local-store.ts'
 import type { IPNSRouting } from './routing/index.ts'
 import type { PublicKey } from '@helia/interface'
@@ -31,8 +32,8 @@ export class IPNS implements IPNSInterface, Startable {
     this.started = false
 
     this.routers = [
-      localStoreRouting(this.localStore),
-      helia(components.routing),
+      localStoreIPNSRouting(this.localStore),
+      heliaIPNSRouting(components.routing),
       ...(init.routers ?? [])
     ]
 
@@ -67,14 +68,13 @@ export class IPNS implements IPNSInterface, Startable {
           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)))
+              const records = values.map(buf => IPNSEntry.decode(buf))
 
               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)
+              await ipnsValidator(key, value, this.components.keychain)
             }
           }
         }
@@ -100,11 +100,11 @@ export class IPNS implements IPNSInterface, Startable {
     this.republisher.stop()
   }
 
-  async publish (keyName: string, value: PublicKey | CID | MultihashDigest | string, options: PublishOptions = {}): Promise<PublishResult> {
+  async publish (keyName: string, value: PublicKey | CID | MultihashDigest | string, options: PublishOptions = {}): Promise<IPNSPublishResult> {
     return this.publisher.publish(keyName, normalizeValue(value), options)
   }
 
-  async * resolve (key: PublicKey | CID<unknown, 0x72> | MultihashDigest | string, options: ResolveOptions = {}): AsyncGenerator<ResolveResult> {
+  async * resolve (key: PublicKey | CID | MultihashDigest | string, options: IPNSResolveOptions = {}): AsyncGenerator<IPNSResolveResult> {
     const { digest } = normalizeKey(key)
 
     yield * this.resolver.resolve(digest, options)

package/src/local-store.ts

@@ -2,14 +2,15 @@ import { Record } from '@libp2p/kad-dht'
 import { CustomProgressEvent } from 'progress-events'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
 import { IPNSPublishMetadata } from './pb/metadata.ts'
 import { dhtRoutingKey, DHT_RECORD_PREFIX, ipnsMetadataKey } from './utils.ts'
-import type { DatastoreProgressEvents, GetOptions, PutOptions } from './routing/index.ts'
+import type { DatastoreProgressEvents, IPNSRoutingGetOptions, IPNSRoutingPutOptions } from './routing/index.ts'
 import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 
 export interface GetResult {
-  record: Uint8Array
+  record: Uint8Array<ArrayBuffer>
   created: Date
 }
 
@@ -32,8 +33,8 @@ export interface LocalStore {
    * @param marshaledRecord - The marshaled IPNS record
    * @param options - options for the put operation including metadata
    */
-  put(routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: PutOptions): Promise<void>
-  get(routingKey: Uint8Array, options?: GetOptions): Promise<GetResult>
+  put(routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: IPNSRoutingPutOptions): Promise<void>
+  get(routingKey: Uint8Array, options?: IPNSRoutingGetOptions): Promise<GetResult>
   has(routingKey: Uint8Array, options?: AbortOptions): Promise<boolean>
   delete(routingKey: Uint8Array, options?: AbortOptions): Promise<void>
   /**
@@ -50,7 +51,7 @@ export interface LocalStore {
  */
 export function localStore (datastore: Datastore, log: Logger): LocalStore {
   return {
-    async put (routingKey: Uint8Array, marshalledRecord: Uint8Array, options: PutOptions = {}) {
+    async put (routingKey: Uint8Array, marshalledRecord: Uint8Array, options: IPNSRoutingPutOptions = {}) {
       try {
         const key = dhtRoutingKey(routingKey)
 
@@ -86,7 +87,7 @@ export function localStore (datastore: Datastore, log: Logger): LocalStore {
         throw err
       }
     },
-    async get (routingKey: Uint8Array, options: GetOptions = {}): Promise<GetResult> {
+    async get (routingKey: Uint8Array, options: IPNSRoutingGetOptions = {}): Promise<GetResult> {
       try {
         const key = dhtRoutingKey(routingKey)
 
@@ -97,7 +98,7 @@ export function localStore (datastore: Datastore, log: Logger): LocalStore {
         const record = Record.deserialize(buf)
 
         return {
-          record: record.value,
+          record: withArrayBuffer(record.value),
           created: record.timeReceived
         }
       } catch (err: any) {

package/src/pb/ipns.proto

@@ -2,7 +2,7 @@
 
 syntax = "proto3";
 
-message IpnsEntry {
+message IPNSEntry {
 	enum ValidityType {
 		// setting an EOL says "this record is valid until..."
 		EOL = 0;

package/src/pb/ipns.ts

@@ -2,19 +2,19 @@ import { decodeMessage, encodeMessage, enumeration, message, streamMessage } fro
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-export interface IpnsEntry {
-  value?: Uint8Array
-  signatureV1?: Uint8Array
-  validityType?: IpnsEntry.ValidityType
-  validity?: Uint8Array
+export interface IPNSEntry {
+  value?: Uint8Array<ArrayBuffer>
+  signatureV1?: Uint8Array<ArrayBuffer>
+  validityType?: IPNSEntry.ValidityType
+  validity?: Uint8Array<ArrayBuffer>
   sequence?: bigint
   ttl?: bigint
-  publicKey?: Uint8Array
-  signatureV2?: Uint8Array
-  data?: Uint8Array
+  publicKey?: Uint8Array<ArrayBuffer>
+  signatureV2?: Uint8Array<ArrayBuffer>
+  data?: Uint8Array<ArrayBuffer>
 }
 
-export namespace IpnsEntry {
+export namespace IPNSEntry {
   export enum ValidityType {
     EOL = 'EOL'
   }
@@ -29,11 +29,11 @@ export namespace IpnsEntry {
     }
   }
 
-  let _codec: Codec<IpnsEntry>
+  let _codec: Codec<IPNSEntry>
 
-  export const codec = (): Codec<IpnsEntry> => {
+  export const codec = (): Codec<IPNSEntry> => {
     if (_codec == null) {
-      _codec = message<IpnsEntry>((obj, w, opts = {}) => {
+      _codec = message<IPNSEntry>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -50,7 +50,7 @@ export namespace IpnsEntry {
 
         if (obj.validityType != null) {
           w.uint32(24)
-          IpnsEntry.ValidityType.codec().encode(obj.validityType, w)
+          IPNSEntry.ValidityType.codec().encode(obj.validityType, w)
         }
 
         if (obj.validity != null) {
@@ -104,7 +104,7 @@ export namespace IpnsEntry {
               break
             }
             case 3: {
-              obj.validityType = IpnsEntry.ValidityType.codec().decode(reader)
+              obj.validityType = IPNSEntry.ValidityType.codec().decode(reader)
               break
             }
             case 4: {
@@ -163,7 +163,7 @@ export namespace IpnsEntry {
             case 3: {
               yield {
                 field: `${prefix}.validityType`,
-                value: IpnsEntry.ValidityType.codec().decode(reader)
+                value: IPNSEntry.ValidityType.codec().decode(reader)
               }
               break
             }
@@ -221,60 +221,60 @@ export namespace IpnsEntry {
     return _codec
   }
 
-  export interface IpnsEntryValueFieldEvent {
+  export interface IPNSEntryValueFieldEvent {
     field: '$.value'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export interface IpnsEntrySignatureV1FieldEvent {
+  export interface IPNSEntrySignatureV1FieldEvent {
     field: '$.signatureV1'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export interface IpnsEntryValidityTypeFieldEvent {
+  export interface IPNSEntryValidityTypeFieldEvent {
     field: '$.validityType'
-    value: IpnsEntry.ValidityType
+    value: IPNSEntry.ValidityType
   }
 
-  export interface IpnsEntryValidityFieldEvent {
+  export interface IPNSEntryValidityFieldEvent {
     field: '$.validity'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export interface IpnsEntrySequenceFieldEvent {
+  export interface IPNSEntrySequenceFieldEvent {
     field: '$.sequence'
     value: bigint
   }
 
-  export interface IpnsEntryTtlFieldEvent {
+  export interface IPNSEntryTtlFieldEvent {
     field: '$.ttl'
     value: bigint
   }
 
-  export interface IpnsEntryPublicKeyFieldEvent {
+  export interface IPNSEntryPublicKeyFieldEvent {
     field: '$.publicKey'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export interface IpnsEntrySignatureV2FieldEvent {
+  export interface IPNSEntrySignatureV2FieldEvent {
     field: '$.signatureV2'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export interface IpnsEntryDataFieldEvent {
+  export interface IPNSEntryDataFieldEvent {
     field: '$.data'
-    value: Uint8Array
+    value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<IpnsEntry>): Uint8Array<ArrayBuffer> {
-    return encodeMessage(obj, IpnsEntry.codec())
+  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 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)
+  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)
   }
 }