@helia/ipns 10.0.0 → 10.0.1-883ff053

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

package/src/routing/pubsub.ts

@@ -9,13 +9,13 @@ import { raceSignal } from 'race-signal'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
 import { InvalidTopicError } from '../errors.ts'
 import { localStore } from '../local-store.ts'
-import { multihashToIPNSRoutingKey } from '../records.ts'
 import { ipnsSelector } from '../selector.ts'
-import { IPNS_STRING_PREFIX, unmarshalIPNSRecord } from '../utils.ts'
+import { IPNS_STRING_PREFIX, multihashToIPNSRoutingKey } from '../utils.ts'
 import { ipnsValidator } from '../validator.ts'
-import type { GetOptions, IPNSRouting, PutOptions } from './index.ts'
+import type { IPNSRoutingGetOptions, IPNSRouting, IPNSRoutingPutOptions } from './index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { Keychain } from '@helia/interface'
 import type { Fetch } from '@libp2p/fetch'
@@ -26,26 +26,26 @@ import type { ProgressEvent } from 'progress-events'
 
 const log = logger('helia:ipns:routing:pubsub')
 
-export interface Message {
+export interface PubSubMessage {
   type: 'signed' | 'unsigned'
   from: PeerId
   topic: string
   data: Uint8Array
 }
 
-export interface Subscription {
+export interface PubSubSubscription {
   topic: string
   subscribe: boolean
 }
 
-export interface SubscriptionChangeData {
+export interface PubSubSubscriptionChangeData {
   peerId: PeerId
-  subscriptions: Subscription[]
+  subscriptions: PubSubSubscription[]
 }
 
 export interface PubSubEvents {
-  'subscription-change': CustomEvent<SubscriptionChangeData>
-  message: CustomEvent<Message>
+  'subscription-change': CustomEvent<PubSubSubscriptionChangeData>
+  message: CustomEvent<PubSubMessage>
 }
 
 export interface PublishResult {
@@ -96,7 +96,7 @@ export type PubSubProgressEvents =
   ProgressEvent<'ipns:pubsub:subscribe', { topic: string }> |
   ProgressEvent<'ipns:pubsub:error', Error>
 
-export class PubSubRouting implements IPNSRouting, Startable {
+export class PubSubIPNSRouting implements IPNSRouting, Startable {
   private readonly subscriptions: Set<string>
   private readonly localStore: LocalStore
   private readonly libp2p: Pick<Libp2p<{ pubsub: PubSub, fetch?: Fetch }>, 'peerId' | 'register' | 'unregister' | 'services'>
@@ -196,7 +196,7 @@ export class PubSubRouting implements IPNSRouting, Startable {
     }
   }
 
-  async #processPubSubMessage (message: Message, options?: AbortOptions): Promise<void> {
+  async #processPubSubMessage (message: PubSubMessage, options?: AbortOptions): Promise<void> {
     log('message received for topic', message.topic)
 
     if (message.type !== 'signed') {
@@ -212,7 +212,7 @@ export class PubSubRouting implements IPNSRouting, Startable {
     await this.#handleRecord(message.topic, topicToKey(message.topic), message.data, false, options)
   }
 
-  async #fetchFromPeer (topic: string, routingKey: Uint8Array, peerId: PeerId, options?: AbortOptions): Promise<Uint8Array> {
+  async #fetchFromPeer (topic: string, routingKey: Uint8Array, peerId: PeerId, options?: AbortOptions): Promise<Uint8Array<ArrayBuffer>> {
     const marshalledRecord = await this.fetchQueue.add(async ({ signal }) => {
       log('fetching ipns record for %m from peer %s', routingKey, peerId)
 
@@ -238,18 +238,17 @@ export class PubSubRouting implements IPNSRouting, Startable {
     return this.#handleRecord(topic, routingKey, marshalledRecord, true, options)
   }
 
-  async #handleRecord (topic: string, routingKey: Uint8Array, marshalledRecord: Uint8Array, publish: boolean, options?: AbortOptions): Promise<Uint8Array> {
-    const record = await unmarshalIPNSRecord(routingKey, marshalledRecord, this.keychain, options)
-    await ipnsValidator(record, options)
+  async #handleRecord (topic: string, routingKey: Uint8Array, marshalledRecord: Uint8Array, publish: boolean, options?: AbortOptions): Promise<Uint8Array<ArrayBuffer>> {
+    const record = await ipnsValidator(routingKey, marshalledRecord, this.keychain, options)
     this.shutdownController.signal.throwIfAborted()
 
     if (await this.localStore.has(routingKey)) {
       const { record: marshaledCurrentRecord } = await this.localStore.get(routingKey, options)
-      const currentRecord = await unmarshalIPNSRecord(routingKey, marshaledCurrentRecord, this.keychain, options)
+      const currentRecord = await ipnsValidator(routingKey, marshaledCurrentRecord, this.keychain, options)
 
-      if (uint8ArrayEquals(marshaledCurrentRecord, record.bytes)) {
+      if (uint8ArrayEquals(marshaledCurrentRecord, marshalledRecord)) {
         log.trace('found identical record for %m', routingKey)
-        return currentRecord.bytes
+        return marshaledCurrentRecord
       }
 
       const records = [currentRecord, record]
@@ -257,7 +256,7 @@ export class PubSubRouting implements IPNSRouting, Startable {
 
       if (index === 0) {
         log.trace('found old record for %m', routingKey)
-        return currentRecord.bytes
+        return marshaledCurrentRecord
       }
     }
 
@@ -276,13 +275,13 @@ export class PubSubRouting implements IPNSRouting, Startable {
       }
     }
 
-    return marshalledRecord
+    return withArrayBuffer(marshalledRecord)
   }
 
   /**
    * Put a value to the pubsub datastore indexed by the received key properly encoded
    */
-  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options: PutOptions = {}): Promise<void> {
+  async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options: IPNSRoutingPutOptions = {}): Promise<void> {
     try {
       const topic = keyToTopic(routingKey)
 
@@ -303,7 +302,7 @@ export class PubSubRouting implements IPNSRouting, Startable {
    * Also, the identifier topic is subscribed to and the pubsub datastore records will be
    * updated once new publishes occur
    */
-  async get (routingKey: Uint8Array, options: GetOptions = {}): Promise<Uint8Array> {
+  async get (routingKey: Uint8Array, options: IPNSRoutingGetOptions = {}): Promise<Uint8Array<ArrayBuffer>> {
     const topic = keyToTopic(routingKey)
 
     try {
@@ -324,7 +323,7 @@ export class PubSubRouting implements IPNSRouting, Startable {
     await raceSignal(delay(this.fetchDelay), this.shutdownController.signal)
 
     const fetchController = new AbortController()
-    const promises: Array<Promise<Uint8Array>> = []
+    const promises: Array<Promise<Uint8Array<ArrayBuffer>>> = []
 
     for (const peerId of this.libp2p.services.pubsub.getSubscribers(topic)) {
       const signal = anySignal([
@@ -447,6 +446,6 @@ function topicToKey (topic: string): Uint8Array {
  * updated records, so the first call to `.get` should be expected
  * to fail!
  */
-export function pubsub (components: PubsubRoutingComponents, init: PubsubRoutingInit = {}): IPNSRouting {
-  return new PubSubRouting(components, init)
+export function pubSubIPNSRouting (components: PubsubRoutingComponents, init: PubsubRoutingInit = {}): IPNSRouting {
+  return new PubSubIPNSRouting(components, init)
 }

package/src/selector.ts

@@ -1,6 +1,7 @@
 import NanoDate from 'timestamp-nano'
-import { IpnsEntry } from './pb/ipns.ts'
-import type { IPNSRecord } from './records.ts'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { IPNSEntry } from './pb/ipns.ts'
+import { decodeExtensibleData } from './utils.ts'
 
 /**
  * Selects the latest valid IPNS record from an array of marshalled IPNS records.
@@ -13,19 +14,21 @@ import type { IPNSRecord } from './records.ts'
  * @param data - Array of marshalled IPNS records to select from
  * @returns The index of the most valid record from the input array
  */
-export function ipnsSelector (key: Uint8Array, data: IPNSRecord[]): number {
+export function ipnsSelector (key: Uint8Array, data: IPNSEntry[]): number {
   const entries = data.map((record, index) => ({
     record,
     index
   }))
 
   entries.sort((a, b) => {
-    // Before we'd sort based on the signature version. Unmarshal now fails if
-    // a record does not have SignatureV2, so that is no longer needed. V1-only
-    // records haven't been issues in a long time.
+    // Before we'd sort based on the signature version. Validation fails if a
+    // record does not have SignatureV2, so that is no longer needed. V1-only
+    // records will have all expired by this point.
+    const aData = decodeExtensibleData(a.record.data)
+    const bData = decodeExtensibleData(b.record.data)
 
-    const aSeq = a.record.sequence
-    const bSeq = b.record.sequence
+    const aSeq = aData.Sequence
+    const bSeq = bData.Sequence
 
     // choose later sequence number
     if (aSeq > bSeq) {
@@ -34,10 +37,10 @@ export function ipnsSelector (key: Uint8Array, data: IPNSRecord[]): number {
       return 1
     }
 
-    if (a.record.validityType === IpnsEntry.ValidityType.EOL && b.record.validityType === IpnsEntry.ValidityType.EOL) {
+    if (aData.ValidityType === IPNSEntry.ValidityType.EOL && bData.ValidityType === IPNSEntry.ValidityType.EOL) {
       // choose longer lived record if sequence numbers the same
-      const recordAValidityDate = NanoDate.fromString(a.record.validity).toDate()
-      const recordBValidityDate = NanoDate.fromString(b.record.validity).toDate()
+      const recordAValidityDate = NanoDate.fromString(uint8ArrayToString(aData.Validity)).toDate()
+      const recordBValidityDate = NanoDate.fromString(uint8ArrayToString(bData.Validity)).toDate()
 
       if (recordAValidityDate.getTime() > recordBValidityDate.getTime()) {
         return -1