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

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)
   }
 }

package/src/records.ts

@@ -2,259 +2,106 @@ import { logger } from '@libp2p/logger'
 import NanoDate from 'timestamp-nano'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { SignatureCreationError } from './errors.ts'
-import { IpnsEntry } from './pb/ipns.ts'
-import { createCborData, ipnsRecordDataForV1Sig, ipnsRecordDataForV2Sig, marshalIPNSRecord } from './utils.ts'
+import { IPNSEntry } from './pb/ipns.ts'
+import { encodeExtensibleData, IDENTITY_CODEC, ipnsRecordDataForV1Sig, ipnsRecordDataForV2Sig } from './utils.ts'
 import type { PrivateKey, PublicKey } from '@helia/interface'
 import type { AbortOptions } from 'abort-error'
-import type { Key } from 'interface-datastore/key'
 
 const log = logger('ipns')
-const DEFAULT_TTL_NS = 5 * 60 * 1e+9 // 5 Minutes or 300 Seconds, as suggested by https://specs.ipfs.tech/ipns/ipns-record/#ttl-uint64
-
-export const namespace = '/ipns/'
-export const namespaceLength = namespace.length
-
-export interface IPNSRecordV1V2 {
-  /**
-   * value of the record
-   */
-  value: string
-
-  /**
-   * signature of the record
-   */
-  signatureV1: Uint8Array
-
-  /**
-   * Type of validation being used
-   */
-  validityType: IpnsEntry.ValidityType
-
-  /**
-   * expiration datetime for the record in RFC3339 format
-   */
-  validity: string
-
-  /**
-   * number representing the version of the record
-   */
-  sequence: bigint
-
-  /**
-   * ttl in nanoseconds
-   */
-  ttl?: bigint
-
-  /**
-   * the public portion of the key that signed this record
-   */
-  publicKey: PublicKey
-
-  /**
-   * the v2 signature of the record
-   */
-  signatureV2: Uint8Array
-
-  /**
-   * extensible data
-   */
-  data: Uint8Array
-
-  /**
-   * The marshalled record
-   */
-  bytes: Uint8Array
-}
-
-export interface IPNSRecordV2 {
-  /**
-   * value of the record
-   */
-  value: string
-
-  /**
-   * the v2 signature of the record
-   */
-  signatureV2: Uint8Array
-
-  /**
-   * Type of validation being used
-   */
-  validityType: IpnsEntry.ValidityType
-
-  /**
-   * If the validity type is EOL, this is the expiration datetime for the record
-   * in RFC3339 format
-   */
-  validity: string
+const DEFAULT_TTL_NS = 300_000_000_000n // 5 Minutes or 300 Seconds, as suggested by https://specs.ipfs.tech/ipns/ipns-record/#ttl-uint64
 
+export interface CreateIPNSRecordOptions extends AbortOptions {
   /**
-   * number representing the version of the record
+   * By default a IPNS V1 and a V2 signature is added to every record. Pass
+   * false here to only add a V2 signature.
+   *
+   * @default true
    */
-  sequence: bigint
-
-  /**
-   * ttl in nanoseconds
-   */
-  ttl?: bigint
-
-  /**
-   * the public portion of the key that signed this record
-   */
-  publicKey: PublicKey
+  v1Compatible?: boolean
 
   /**
-   * extensible data
+   * 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_000_000n
    */
-  data: Uint8Array
+  ttlNs?: bigint
 
   /**
-   * The marshalled record
+   * 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.
    */
-  bytes: Uint8Array
-}
-
-export type IPNSRecord = IPNSRecordV1V2 | IPNSRecordV2
-
-export interface IPNSRecordData {
-  Value: Uint8Array
-  Validity: Uint8Array
-  ValidityType: IpnsEntry.ValidityType
-  Sequence: bigint
-  TTL: bigint
-}
-
-export interface IDKeys {
-  routingPubKey: Key
-  pkKey: Key
-  routingKey: Key
-  ipnsKey: Key
-}
-
-export interface CreateOptions extends AbortOptions {
-  ttlNs?: number | bigint
-  v1Compatible?: boolean
-}
-
-export interface CreateV2OrV1Options extends AbortOptions {
-  v1Compatible: true
-}
-
-export interface CreateV2Options extends AbortOptions {
-  v1Compatible: false
-}
-
-const defaultCreateOptions: CreateOptions = {
-  v1Compatible: true,
-  ttlNs: DEFAULT_TTL_NS
+  data?: Record<string, any>
 }
 
 /**
- * Creates a new IPNS record and signs it with the given private key.
- * The IPNS Record validity should follow the [RFC3339]{@link https://www.ietf.org/rfc/rfc3339.txt} with nanoseconds precision.
- * Note: This function does not embed the public key. If you want to do that, use `EmbedPublicKey`.
- *
- * The passed value can be a CID, a PublicKey or an arbitrary string path e.g. `/ipfs/...` or `/ipns/...`.
+ * A low-level function that creates a new IPNS record and signs it with the
+ * passed private key.
  *
- * CIDs will be converted to v1 and stored in the record as a string similar to: `/ipfs/${cid}`
- * PublicKeys will create recursive records, eg. the record value will be `/ipns/${cidV1Libp2pKey}`
- * String paths will be stored in the record as-is, but they must start with `"/"`
+ * The IPNS Record validity should follow the [RFC3339]{@link https://www.ietf.org/rfc/rfc3339.txt}
+ * with nanosecond precision.
  *
- * @param {PrivateKey} privateKey - the private key for signing the record.
- * @param {CID | PublicKey | string} value - content to be stored in the record.
- * @param {number | bigint} seq - number representing the current version of the record.
- * @param {number} lifetime - lifetime of the record (in milliseconds).
- * @param {CreateOptions} options - additional create options.
+ * The passed value should be a string path e.g. `/ipfs/...` or `/ipns/...`.
  */
-export async function createIPNSRecord (privateKey: PrivateKey, value: string, seq: number | bigint, lifetime: number, options?: CreateV2OrV1Options): Promise<IPNSRecordV1V2>
-export async function createIPNSRecord (privateKey: PrivateKey, value: string, seq: number | bigint, lifetime: number, options: CreateV2Options): Promise<IPNSRecordV2>
-export async function createIPNSRecord (privateKey: PrivateKey, value: string, seq: number | bigint, lifetime: number, options: CreateOptions): Promise<IPNSRecordV1V2>
-export async function createIPNSRecord (privateKey: PrivateKey, value: string, seq: number | bigint, lifetime: number, options: CreateOptions = defaultCreateOptions): Promise<IPNSRecord> {
+export async function createIPNSRecord (privateKey: PrivateKey, val: string, seq: number | bigint, lifetime: number, options?: CreateIPNSRecordOptions): Promise<IPNSEntry> {
+  seq = BigInt(seq)
+  const value = uint8ArrayFromString(val)
+  // convert ttl from milliseconds to nanoseconds as createIPNSRecord expects
+  const ttlNs = options?.ttlNs ?? DEFAULT_TTL_NS
+
   // Validity in ISOString with nanoseconds precision and validity type EOL
   const expirationDate = new NanoDate(Date.now() + Number(lifetime))
-  const validityType = IpnsEntry.ValidityType.EOL
-  const ttlNs = BigInt(options.ttlNs ?? DEFAULT_TTL_NS)
-
-  return _create(privateKey, value, seq, validityType, expirationDate.toString(), ttlNs, options)
-}
-
-/**
- * Same as create(), but instead of generating a new Date, it receives the intended expiration time
- * WARNING: nano precision is not standard, make sure the value in seconds is 9 orders of magnitude lesser than the one provided.
- *
- * The passed value can be a CID, a PublicKey or an arbitrary string path e.g. `/ipfs/...` or `/ipns/...`.
- *
- * CIDs will be converted to v1 and stored in the record as a string similar to: `/ipfs/${cid}`
- * PublicKeys will create recursive records, eg. the record value will be `/ipns/${cidV1Libp2pKey}`
- * String paths will be stored in the record as-is, but they must start with `"/"`
- *
- * @param {PrivateKey} privateKey - the private key for signing the record.
- * @param {CID | PublicKey | string} value - content to be stored in the record.
- * @param {number | bigint} seq - number representing the current version of the record.
- * @param {string} expiration - expiration datetime for record in the [RFC3339]{@link https://www.ietf.org/rfc/rfc3339.txt} with nanoseconds precision.
- * @param {CreateOptions} options - additional creation options.
- */
-export async function createIPNSRecordWithExpiration (privateKey: PrivateKey, value: string, seq: number | bigint, expiration: string, options?: CreateV2OrV1Options): Promise<IPNSRecordV1V2>
-export async function createIPNSRecordWithExpiration (privateKey: PrivateKey, value: string, seq: number | bigint, expiration: string, options: CreateV2Options): Promise<IPNSRecordV2>
-export async function createIPNSRecordWithExpiration (privateKey: PrivateKey, value: string, seq: number | bigint, expiration: string, options: CreateOptions): Promise<IPNSRecordV1V2>
-export async function createIPNSRecordWithExpiration (privateKey: PrivateKey, value: string, seq: number | bigint, expiration: string, options: CreateOptions = defaultCreateOptions): Promise<IPNSRecord> {
-  const expirationDate = NanoDate.fromString(expiration)
-  const validityType = IpnsEntry.ValidityType.EOL
-  const ttlNs = BigInt(options.ttlNs ?? DEFAULT_TTL_NS)
-
-  return _create(privateKey, value, seq, validityType, expirationDate.toString(), ttlNs, options)
-}
+  const validityType = IPNSEntry.ValidityType.EOL
+  const validity = uint8ArrayFromString(expirationDate.toString())
+
+  const data = encodeExtensibleData({
+    ...(options?.data ?? {}),
+    Value: value,
+    Validity: validity,
+    // @ts-expect-error should be a number
+    ValidityType: 0,
+    Sequence: seq,
+    TTL: ttlNs
+  })
 
-const _create = async (privateKey: PrivateKey, value: string, seq: number | bigint, validityType: IpnsEntry.ValidityType, validity: string, ttl: bigint, options: CreateOptions = defaultCreateOptions): Promise<IPNSRecord> => {
-  seq = BigInt(seq)
-  const isoValidity = uint8ArrayFromString(validity)
-  const data = createCborData(value, validityType, isoValidity, seq, ttl)
   const sigData = ipnsRecordDataForV2Sig(data)
   const signatureV2 = await privateKey.sign(sigData, options)
-  const publicKey = shouldEmbedPublicKey(privateKey.publicKey) ? privateKey.publicKey : undefined
-  let record: any
-
-  if (options.v1Compatible === true) {
-    const signatureV1 = await signLegacyV1(privateKey, value, validityType, isoValidity)
+  let record: IPNSEntry
 
+  if (options?.v1Compatible === false) {
     record = {
-      value,
-      signatureV1,
-      validity,
-      validityType,
-      sequence: seq,
-      ttl,
       signatureV2,
-      data,
-      publicKey
+      data
     }
   } else {
     record = {
       value,
-      validity,
+      signatureV1: await signLegacyV1(privateKey, value, validityType, validity),
       validityType,
+      validity,
       sequence: seq,
-      ttl,
+      ttl: ttlNs,
       signatureV2,
-      data,
-      publicKey
+      data
     }
   }
 
-  record.bytes = marshalIPNSRecord(record)
+  if (shouldEmbedPublicKey(privateKey.publicKey)) {
+    record.publicKey = privateKey.publicKey.toProtobuf()
+  }
 
   return record
 }
 
-export { unmarshalIPNSRecord } from './utils.ts'
-export { marshalIPNSRecord } from './utils.ts'
-export { multihashToIPNSRoutingKey } from './utils.ts'
-export { multihashFromIPNSRoutingKey } from './utils.ts'
-
 /**
  * Sign ipns record data using the legacy V1 signature scheme
  */
-const signLegacyV1 = async (privateKey: PrivateKey, value: string, validityType: IpnsEntry.ValidityType, validity: Uint8Array, options?: AbortOptions): Promise<Uint8Array> => {
+const signLegacyV1 = async (privateKey: PrivateKey, value: Uint8Array, validityType: IPNSEntry.ValidityType, validity: Uint8Array, options?: AbortOptions): Promise<Uint8Array<ArrayBuffer>> => {
   try {
     const dataForSignature = ipnsRecordDataForV1Sig(value, validityType, validity)
 
@@ -269,5 +116,5 @@ const signLegacyV1 = async (privateKey: PrivateKey, value: string, validityType:
  * Returns true if the public key multihash is not an identity hash
  */
 function shouldEmbedPublicKey (key: PublicKey): boolean {
-  return key.toMultihash().code !== 0
+  return key.toMultihash().code !== IDENTITY_CODEC
 }

package/src/routing/helia.ts

@@ -1,5 +1,5 @@
 import { CustomProgressEvent } from 'progress-events'
-import type { GetOptions, PutOptions } from './index.ts'
+import type { IPNSRoutingGetOptions, IPNSRoutingPutOptions } from './index.ts'
 import type { IPNSRouting } from '../index.ts'
 import type { Routing } from '@helia/interface'
 import type { ProgressEvent } from 'progress-events'
@@ -11,14 +11,14 @@ export interface HeliaRoutingComponents {
 export type HeliaRoutingProgressEvents =
   ProgressEvent<'ipns:routing:helia:error', Error>
 
-export class HeliaRouting implements IPNSRouting {
+export class HeliaIPNSRouting implements IPNSRouting {
   private readonly routing: Routing
 
   constructor (routing: Routing) {
     this.routing = routing
   }
 
-  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options: PutOptions = {}): Promise<void> {
+  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options: IPNSRoutingPutOptions = {}): Promise<void> {
     try {
       await this.routing.put(routingKey, marshaledRecord, options)
     } catch (err: any) {
@@ -27,7 +27,7 @@ export class HeliaRouting implements IPNSRouting {
     }
   }
 
-  async get (routingKey: Uint8Array, options: GetOptions = {}): Promise<Uint8Array> {
+  async get (routingKey: Uint8Array, options: IPNSRoutingGetOptions = {}): Promise<Uint8Array<ArrayBuffer>> {
     try {
       return await this.routing.get(routingKey, options)
     } catch (err: any) {
@@ -45,6 +45,6 @@ export class HeliaRouting implements IPNSRouting {
  * The helia routing uses any available Routers configured on the passed Helia
  * node. This could be libp2p, HTTP API Delegated Routing, etc.
  */
-export function helia (routing: Routing): IPNSRouting {
-  return new HeliaRouting(routing)
+export function heliaIPNSRouting (routing: Routing): IPNSRouting {
+  return new HeliaIPNSRouting(routing)
 }

package/src/routing/index.ts

@@ -5,11 +5,11 @@ import type { IPNSPublishMetadata } from '../pb/metadata.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { ProgressOptions } from 'progress-events'
 
-export interface PutOptions extends AbortOptions, ProgressOptions {
+export interface IPNSRoutingPutOptions extends AbortOptions, ProgressOptions {
   metadata?: IPNSPublishMetadata
 }
 
-export interface GetOptions extends AbortOptions, ProgressOptions {
+export interface IPNSRoutingGetOptions extends AbortOptions, ProgressOptions {
   /**
    * Pass false to not perform validation actions
    *
@@ -19,8 +19,8 @@ export interface GetOptions extends AbortOptions, ProgressOptions {
 }
 
 export interface IPNSRouting {
-  put(routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: PutOptions): Promise<void>
-  get(routingKey: Uint8Array, options?: GetOptions): Promise<Uint8Array>
+  put(routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: IPNSRoutingPutOptions): Promise<void>
+  get(routingKey: Uint8Array, options?: IPNSRoutingGetOptions): Promise<Uint8Array>
 }
 
 export type { DatastoreProgressEvents }
@@ -32,6 +32,6 @@ export type IPNSRoutingProgressEvents =
   HeliaRoutingProgressEvents |
   PubSubProgressEvents
 
-export { helia } from './helia.ts'
-export { pubsub } from './pubsub.ts'
-export type { PubsubRoutingComponents, PubSub, Message, PublishResult, PubSubEvents } from './pubsub.ts'
+export { heliaIPNSRouting } from './helia.ts'
+export { pubSubIPNSRouting } from './pubsub.ts'
+export type { PubsubRoutingComponents, PubSub, PubSubMessage, PublishResult, PubSubEvents, PubSubSubscription, PubSubSubscriptionChangeData } from './pubsub.ts'

package/src/routing/local-store.ts

@@ -1,18 +1,18 @@
 import type { LocalStore } from '../local-store.ts'
-import type { IPNSRouting, PutOptions, GetOptions } from './index.ts'
+import type { IPNSRouting, IPNSRoutingPutOptions, IPNSRoutingGetOptions } from './index.ts'
 
-class LocalStoreRouting {
+class LocalStoreIPNSRouting {
   private localStore: LocalStore
 
   constructor (localStore: LocalStore) {
     this.localStore = localStore
   }
 
-  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: PutOptions): Promise<void> {
+  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options?: IPNSRoutingPutOptions): Promise<void> {
     await this.localStore.put(routingKey, marshaledRecord, options)
   }
 
-  async get (routingKey: Uint8Array, options?: GetOptions): Promise<Uint8Array> {
+  async get (routingKey: Uint8Array, options?: IPNSRoutingGetOptions): Promise<Uint8Array<ArrayBuffer>> {
     const { record } = await this.localStore.get(routingKey, options)
 
     return record
@@ -26,6 +26,6 @@ class LocalStoreRouting {
 /**
  * Returns an IPNSRouting implementation that reads/writes to the local store
  */
-export function localStoreRouting (localStore: LocalStore): IPNSRouting {
-  return new LocalStoreRouting(localStore)
+export function localStoreIPNSRouting (localStore: LocalStore): IPNSRouting {
+  return new LocalStoreIPNSRouting(localStore)
 }