@helia/ipns 10.0.1-cee53d7d → 10.0.2-688bd9de

package/src/index.ts

@@ -37,7 +37,6 @@
  * 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)
@@ -66,7 +65,6 @@
  * 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)
@@ -105,15 +103,13 @@
  * may fail to be published with "Insufficient peers" errors.
  *
  * ```TypeScript
- * import { ipns } from '@helia/ipns'
- * import { pubsub } from '@helia/ipns/routing'
+ * import { ipns, pubSubIPNSRouting } from '@helia/ipns'
  * import { withLibp2p, libp2pDefaults } from '@helia/libp2p'
  * import { unixfs } from '@helia/unixfs'
- * import { generateKeyPair } from '@libp2p/crypto/keys'
  * import { floodsub } from '@libp2p/floodsub'
  * import { createHelia } from 'helia'
  * import type { Helia } from '@helia/interface'
- * import type { PubSub } from '@helia/ipns/routing'
+ * import type { PubSub } from '@helia/ipns'
  * import type { DefaultLibp2pServices } from '@helia/libp2p'
  * import type { FloodSub } from '@libp2p/floodsub'
  * import type { Libp2p } from '@libp2p/interface'
@@ -125,7 +121,7 @@
  *
  * const name = ipns(helia, {
  *  routers: [
- *    pubsub(helia)
+ *    pubSubIPNSRouting(helia)
  *  ]
  * })
  *
@@ -147,10 +143,10 @@ import { CID } from 'multiformats/cid'
 import { IPNSResolver as IPNSResolverClass } from './ipns/resolver.ts'
 import { IPNS as IPNSClass } from './ipns.ts'
 import { localStore } from './local-store.ts'
-import { helia } from './routing/index.ts'
-import { localStoreRouting } from './routing/local-store.ts'
+import { heliaIPNSRouting } from './routing/index.ts'
+import { localStoreIPNSRouting } from './routing/local-store.ts'
 import type { IPNSResolverComponents } from './ipns/resolver.ts'
-import type { IPNSRecord } from './records.ts'
+import type { IPNSEntry } from './pb/ipns.ts'
 import type { IPNSRouting, IPNSRoutingProgressEvents } from './routing/index.ts'
 import type { Routing, HeliaEvents, Keychain, PublicKey } from '@helia/interface'
 import type { ComponentLogger, TypedEventEmitter } from '@libp2p/interface'
@@ -159,14 +155,29 @@ import type { Datastore } from 'interface-datastore'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
+export * from './routing/index.ts'
+export * from './pb/ipns.ts'
+
+export {
+  multihashFromIPNSRoutingKey,
+  multihashToIPNSRoutingKey
+} from './utils.ts'
+
+export {
+  createIPNSRecord
+} from './records.ts'
+export type {
+  CreateIPNSRecordOptions
+} from './records.ts'
+
 export type PublishProgressEvents =
   ProgressEvent<'ipns:publish:start'> |
-  ProgressEvent<'ipns:publish:success', IPNSRecord> |
+  ProgressEvent<'ipns:publish:success', IPNSEntry> |
   ProgressEvent<'ipns:publish:error', Error>
 
 export type ResolveProgressEvents =
   ProgressEvent<'ipns:resolve:start', unknown> |
-  ProgressEvent<'ipns:resolve:success', IPNSRecord> |
+  ProgressEvent<'ipns:resolve:success', IPNSEntry> |
   ProgressEvent<'ipns:resolve:error', Error>
 
 export type DatastoreProgressEvents =
@@ -177,7 +188,8 @@ export type DatastoreProgressEvents =
 
 export interface PublishOptions extends AbortOptions, ProgressOptions<PublishProgressEvents | IPNSRoutingProgressEvents> {
   /**
-   * Time duration of the signature validity in ms
+   * Time duration of the signature validity in ms - after this many ms have
+   * expired the record will be invalidated.
    *
    * @default 172_800_000
    */
@@ -199,16 +211,44 @@ export interface PublishOptions extends AbortOptions, ProgressOptions<PublishPro
   v1Compatible?: boolean
 
   /**
-   * The TTL of the record in ms
+   * The TTL of the record in ms - after this many ms have expired, resolving
+   * the record will query the routing for an updated version.
+   *
+   * Before this many ms have expired any locally stored copy will be treated as
+   * the latest version and the routing will not be queried.
    *
    * @default 300_000
    */
   ttl?: number
+
+  /**
+   * Extensible data that will be added to the IPNS record data and signed to
+   * verify it's integrity.
+   *
+   * Note that this data will be encoded as DAG-CBOR so it must be valid.
+   *
+   * It is recommended that any custom fields set here are prefixed with `_` to
+   * avoid collision with any mandatory fields added to future versions of the
+   * IPNS specification.
+   *
+   * @see https://specs.ipfs.tech/ipns/ipns-record/#extensible-data-dag-cbor
+   */
+  data?: Record<string, any>
 }
 
-export interface IPNSRecordMetadata {
-  keyName: string
-  lifetime: number
+/**
+ * Extensible data from the record `data` field.
+ *
+ * The wire format of this data is DAG-CBOR.
+ *
+ * @see https://specs.ipfs.tech/ipns/ipns-record/#extensible-data-dag-cbor
+ */
+export interface IPNSRecordData extends Record<string, any> {
+  Value: Uint8Array<ArrayBuffer>
+  Validity: Uint8Array<ArrayBuffer>
+  ValidityType: IPNSEntry.ValidityType
+  Sequence: bigint
+  TTL: bigint
 }
 
 export interface IPNSResolveOptions extends AbortOptions, ProgressOptions<ResolveProgressEvents | IPNSRoutingProgressEvents> {
@@ -225,20 +265,33 @@ export interface IPNSResolveOptions extends AbortOptions, ProgressOptions<Resolv
    * @default false
    */
   nocache?: boolean
+
+  /**
+   * If true, ensure the record fields and signature are valid. If false, just
+   * return the record.
+   *
+   * @default true
+   */
+  validate?: boolean
 }
 
 export interface IPNSResolveResult {
   /**
    * The resolved record
    */
-  record: IPNSRecord
+  record: IPNSEntry
+
+  /**
+   * The value contained within the IPNS record
+   */
+  value: string
 }
 
 export interface IPNSPublishResult {
   /**
    * The published record
    */
-  record: IPNSRecord
+  record: IPNSEntry
 
   /**
    * The IPNS name that can be used to resolve this record
@@ -309,7 +362,7 @@ export interface IPNS {
   resolve(name: CID | PublicKey | MultihashDigest | string, options?: IPNSResolveOptions): AsyncGenerator<IPNSResolveResult>
 
   /**
-   * Stop republishing of an IPNS record
+   * Stop republishing of an IPNS record.
    *
    * This will delete the last signed IPNS record from the datastore.
    *
@@ -319,9 +372,6 @@ export interface IPNS {
   unpublish(keyName: string, options?: AbortOptions): Promise<void>
 }
 
-export type { IPNSRouting } from './routing/index.ts'
-export type { IPNSRecord } from './records.ts'
-
 export interface IPNSComponents {
   datastore: Datastore
   routing: Routing
@@ -366,8 +416,8 @@ export function ipns (components: IPNSComponents, options: IPNSOptions = {}): IP
 export function ipnsResolver (components: IPNSResolverComponents, options: IPNSResolverOptions = {}): IPNSResolver {
   const store = localStore(components.datastore, components.logger.forComponent('helia:ipns:local-store'))
   const routers = [
-    localStoreRouting(store),
-    helia(components.routing),
+    localStoreIPNSRouting(store),
+    heliaIPNSRouting(components.routing),
     ...(options.routers ?? [])
   ]
 

package/src/ipns/publisher.ts

@@ -1,8 +1,9 @@
 import { base36 } from 'multiformats/bases/base36'
 import { CustomProgressEvent } from 'progress-events'
-import { DEFAULT_LIFETIME_MS, DEFAULT_TTL_NS } from '../constants.ts'
+import { DEFAULT_LIFETIME_MS } from '../constants.ts'
+import { IPNSEntry } from '../pb/ipns.ts'
 import { createIPNSRecord } from '../records.ts'
-import { marshalIPNSRecord, multihashToIPNSRoutingKey, unmarshalIPNSRecord } from '../utils.ts'
+import { decodeExtensibleData, multihashToIPNSRoutingKey } from '../utils.ts'
 import type { IPNSPublishResult, PublishOptions } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
@@ -42,31 +43,43 @@ export class IPNSPublisher {
       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 = await unmarshalIPNSRecord(routingKey, record, this.keychain, options)
-        sequenceNumber = existingRecord.sequence + 1n
+        const existingRecord = IPNSEntry.decode(record)
+        const data = decodeExtensibleData(existingRecord.data)
+        sequenceNumber = (data.Sequence ?? 0n) + 1n
       }
 
-      // convert ttl from milliseconds to nanoseconds as createIPNSRecord expects
-      const ttlNs = options.ttl != null ? BigInt(options.ttl) * 1_000_000n : DEFAULT_TTL_NS
       const lifetime = options.lifetime ?? DEFAULT_LIFETIME_MS
-      const record = await createIPNSRecord(key, value, sequenceNumber, lifetime, { ...options, ttlNs })
-      const marshaledRecord = marshalIPNSRecord(record)
+      const record = await createIPNSRecord(key, value, sequenceNumber, lifetime, {
+        ...options,
+        // convert ttl from milliseconds to nanoseconds as createIPNSRecord expects
+        ttlNs: options.ttl != null ? BigInt(options.ttl) * 1_000_000n : undefined
+      })
+      const marshaledRecord = IPNSEntry.encode(record)
 
       if (options.offline === true) {
         // only store record locally
-        await this.localStore.put(routingKey, marshaledRecord, { ...options, metadata: { keyName, lifetime } })
+        await this.localStore.put(routingKey, marshaledRecord, {
+          ...options,
+          metadata: {
+            keyName,
+            lifetime
+          }
+        })
       } else {
         // publish record to routing (including the local store)
         await Promise.all(this.routers.map(async r => {
-          await r.put(routingKey, marshaledRecord, { ...options, metadata: { keyName, lifetime } })
+          await r.put(routingKey, marshaledRecord, {
+            ...options,
+            metadata: {
+              keyName,
+              lifetime
+            }
+          })
         }))
       }
 
       return {
-        record: {
-          ...record,
-          publicKey: key.publicKey
-        },
+        record,
         name: `/ipns/${key.publicKey.toCID().toString(base36)}`,
         publicKey: key.publicKey
       }

package/src/ipns/republisher.ts

@@ -1,9 +1,10 @@
 import { Queue, repeatingTask } from '@libp2p/utils'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { DEFAULT_REPUBLISH_CONCURRENCY, DEFAULT_REPUBLISH_INTERVAL_MS, DEFAULT_TTL_NS } from '../constants.ts'
+import { IPNSEntry } from '../pb/ipns.ts'
 import { createIPNSRecord } from '../records.ts'
-import { marshalIPNSRecord, unmarshalIPNSRecord } from '../utils.ts'
-import { shouldRepublish } from '../utils.ts'
-import type { IPNSRecord } from '../index.ts'
+import { decodeExtensibleData, shouldRepublish } from '../utils.ts'
+import type { IPNSRecordData } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
 import type { Keychain, PrivateKey } from '@helia/interface'
@@ -78,7 +79,7 @@ export class IPNSRepublisher {
     })
 
     try {
-      const recordsToRepublish: Array<{ routingKey: Uint8Array, record: IPNSRecord }> = []
+      const recordsToRepublish: Array<{ routingKey: Uint8Array, record: IPNSEntry }> = []
       let listed = 0
 
       // Find all records using the localStore.list method
@@ -91,21 +92,38 @@ export class IPNSRepublisher {
           this.log('no metadata found for record %b, skipping', routingKey)
           continue
         }
-        let ipnsRecord: IPNSRecord
+
+        let ipnsRecord: IPNSEntry
+
         try {
-          ipnsRecord = await unmarshalIPNSRecord(routingKey, record, this.keychain, options)
-        } catch (err: any) {
-          this.log.error('error unmarshaling record - %e', err)
+          ipnsRecord = IPNSEntry.decode(record)
+        } catch (err) {
+          this.log.trace('skipping invalid record %b because could not decode', routingKey)
+          continue
+        }
+
+        if (ipnsRecord.data == null) {
+          this.log.trace('skipping record %b because data was missing', routingKey)
+          continue
+        }
+
+        let data: IPNSRecordData
+
+        try {
+          data = decodeExtensibleData(ipnsRecord.data)
+        } catch {
+          this.log.trace('skipping record %b because could not decode data', routingKey)
           continue
         }
 
         // Only republish records that are within the DHT or record expiry threshold
-        if (!shouldRepublish(ipnsRecord, created)) {
+        if (!shouldRepublish(created, new Date(uint8ArrayToString(data.Validity)))) {
           this.log.trace('skipping record %b within republish threshold', routingKey)
           continue
         }
-        const sequenceNumber = ipnsRecord.sequence + 1n
-        const ttlNs = ipnsRecord.ttl ?? DEFAULT_TTL_NS
+
+        const sequenceNumber = data.Sequence + 1n
+        const ttlNs = data.TTL ?? DEFAULT_TTL_NS
         let privKey: PrivateKey
 
         try {
@@ -116,7 +134,7 @@ export class IPNSRepublisher {
         }
 
         try {
-          const updatedRecord = await createIPNSRecord(privKey, ipnsRecord.value, sequenceNumber, metadata.lifetime, {
+          const updatedRecord = await createIPNSRecord(privKey, uint8ArrayToString(data.Value), sequenceNumber, metadata.lifetime, {
             ...options,
             ttlNs
           })
@@ -137,7 +155,7 @@ export class IPNSRepublisher {
         // Add job to queue to republish the record to all routers
         queue.add(async () => {
           try {
-            const marshaledRecord = marshalIPNSRecord(record)
+            const marshaledRecord = IPNSEntry.encode(record)
             await Promise.all(
               this.routers.map(r => r.put(routingKey, marshaledRecord, options))
             )

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, IPNSResolveOptions, IPNSResolveResult } 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'
@@ -42,22 +44,33 @@ export class IPNSResolver {
     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: IPNSResolveOptions = {}): 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,12 +1,13 @@
 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, IPNSPublishResult, PublishOptions, IPNSResolveOptions, IPNSResolveResult } from './index.ts'
 import type { LocalStore } from './local-store.ts'
@@ -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)
             }
           }
         }

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;