@helia/ipns 1.1.1 → 1.1.3

package/src/index.ts

@@ -62,22 +62,24 @@
  * ```
  */
 
-import type { AbortOptions } from '@libp2p/interfaces'
-import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
+import { isPeerId, type PeerId } from '@libp2p/interface-peer-id'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
+import { peerIdFromString } from '@libp2p/peer-id'
 import { create, marshal, peerIdToRoutingKey, unmarshal } from 'ipns'
-import type { IPNSEntry } from 'ipns'
-import type { IPNSRouting, IPNSRoutingEvents } from './routing/index.js'
+import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
 import { CID } from 'multiformats/cid'
-import { resolveDnslink } from './utils/resolve-dns-link.js'
-import { logger } from '@libp2p/logger'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { ProgressEvent, ProgressOptions } from 'progress-events'
 import { CustomProgressEvent } from 'progress-events'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { localStore, type LocalStore } from './routing/local-store.js'
+import { resolveDnslink } from './utils/resolve-dns-link.js'
+import type { IPNSRouting, IPNSRoutingEvents } from './routing/index.js'
+import type { AbortOptions } from '@libp2p/interfaces'
 import type { Datastore } from 'interface-datastore'
-import { localStore, LocalStore } from './routing/local-store.js'
+import type { IPNSEntry } from 'ipns'
+import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
 const log = logger('helia:ipns')
 
@@ -221,13 +223,13 @@ class DefaultIPNS implements IPNS {
     const record = await this.#findIpnsRecord(routingKey, options)
     const str = uint8ArrayToString(record.value)
 
-    return await this.#resolve(str, options)
+    return this.#resolve(str, options)
   }
 
   async resolveDns (domain: string, options: ResolveDNSOptions = {}): Promise<CID> {
     const dnslink = await resolveDnslink(domain, options)
 
-    return await this.#resolve(dnslink, options)
+    return this.#resolve(dnslink, options)
   }
 
   republish (options: RepublishOptions = {}): void {
@@ -273,7 +275,7 @@ class DefaultIPNS implements IPNS {
       const scheme = parts[1]
 
       if (scheme === 'ipns') {
-        return await this.resolve(peerIdFromString(parts[2]), options)
+        return this.resolve(peerIdFromString(parts[2]), options)
       } else if (scheme === 'ipfs') {
         return CID.parse(parts[2])
       }
@@ -295,16 +297,30 @@ class DefaultIPNS implements IPNS {
       ]
     }
 
-    const unmarshaledRecord = await Promise.any(
-      routers.map(async (router) => {
-        const unmarshaledRecord = await router.get(routingKey, options)
-        await ipnsValidator(routingKey, unmarshaledRecord)
+    const records: Uint8Array[] = []
 
-        return unmarshaledRecord
+    await Promise.all(
+      routers.map(async (router) => {
+        try {
+          const record = await router.get(routingKey, options)
+          await ipnsValidator(routingKey, record)
+
+          records.push(record)
+        } catch (err) {
+          log.error('error finding IPNS record', err)
+        }
       })
     )
 
-    return unmarshal(unmarshaledRecord)
+    if (records.length === 0) {
+      throw new CodeError('Could not find record for routing key', 'ERR_NOT_FOUND')
+    }
+
+    const record = records[ipnsSelector(routingKey, records)]
+
+    await this.localStore.put(routingKey, record, options)
+
+    return unmarshal(record)
   }
 }
 

package/src/routing/dht.ts

@@ -1,6 +1,6 @@
-import type { IPNSRouting } from '../index.js'
+import { CustomProgressEvent, type ProgressEvent } from 'progress-events'
 import type { GetOptions, PutOptions } from './index.js'
-import { CustomProgressEvent, ProgressEvent } from 'progress-events'
+import type { IPNSRouting } from '../index.js'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 
 export interface DHTRoutingComponents {

package/src/routing/index.ts

@@ -1,8 +1,8 @@
-import type { ProgressOptions } from 'progress-events'
-import type { AbortOptions } from '@libp2p/interfaces'
 import type { DHTProgressEvents } from './dht.js'
 import type { DatastoreProgressEvents } from './local-store.js'
 import type { PubSubProgressEvents } from './pubsub.js'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { ProgressOptions } from 'progress-events'
 
 export interface PutOptions extends AbortOptions, ProgressOptions {
 

package/src/routing/local-store.ts

@@ -1,9 +1,9 @@
-import { CustomProgressEvent, ProgressEvent } from 'progress-events'
-import type { AbortOptions } from '@libp2p/interfaces'
 import { Libp2pRecord } from '@libp2p/record'
-import { Datastore, Key } from 'interface-datastore'
+import { type Datastore, Key } from 'interface-datastore'
+import { CustomProgressEvent, type ProgressEvent } from 'progress-events'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { GetOptions, IPNSRouting, PutOptions } from '../routing'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 function dhtRoutingKey (key: Uint8Array): Key {
   return new Key('/dht/record/' + uint8ArrayToString(key, 'base32'), false)
@@ -25,12 +25,12 @@ export interface LocalStore extends IPNSRouting {
  */
 export function localStore (datastore: Datastore): LocalStore {
   return {
-    async put (routingKey: Uint8Array, marshaledRecord: Uint8Array, options: PutOptions = {}) {
+    async put (routingKey: Uint8Array, marshalledRecord: Uint8Array, options: PutOptions = {}) {
       try {
         const key = dhtRoutingKey(routingKey)
 
         // Marshal to libp2p record as the DHT does
-        const record = new Libp2pRecord(routingKey, marshaledRecord, new Date())
+        const record = new Libp2pRecord(routingKey, marshalledRecord, new Date())
 
         options.onProgress?.(new CustomProgressEvent('ipns:routing:datastore:put'))
         await datastore.put(key, record.serialize(), options)
@@ -57,7 +57,7 @@ export function localStore (datastore: Datastore): LocalStore {
     },
     async has (routingKey: Uint8Array, options: AbortOptions = {}): Promise<boolean> {
       const key = dhtRoutingKey(routingKey)
-      return await datastore.has(key, options)
+      return datastore.has(key, options)
     }
   }
 }

package/src/routing/pubsub.ts

@@ -1,17 +1,17 @@
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
 import { peerIdToRoutingKey } from 'ipns'
+import { ipnsSelector } from 'ipns/selector'
+import { ipnsValidator } from 'ipns/validator'
+import { CustomProgressEvent, type ProgressEvent } from 'progress-events'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { logger } from '@libp2p/logger'
+import { localStore, type LocalStore } from './local-store.js'
+import type { GetOptions, IPNSRouting, PutOptions } from './index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Message, PublishResult, PubSub } from '@libp2p/interface-pubsub'
 import type { Datastore } from 'interface-datastore'
-import type { GetOptions, IPNSRouting, PutOptions } from './index.js'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { localStore, LocalStore } from './local-store.js'
-import { ipnsValidator } from 'ipns/validator'
-import { ipnsSelector } from 'ipns/selector'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { CustomProgressEvent, ProgressEvent } from 'progress-events'
 
 const log = logger('helia:ipns:routing:pubsub')
 
@@ -19,7 +19,9 @@ export interface PubsubRoutingComponents {
   datastore: Datastore
   libp2p: {
     peerId: PeerId
-    pubsub: PubSub
+    services: {
+      pubsub: PubSub
+    }
   }
 }
 
@@ -46,7 +48,7 @@ class PubSubRouting implements IPNSRouting {
     this.subscriptions = []
     this.localStore = localStore(components.datastore)
     this.peerId = components.libp2p.peerId
-    this.pubsub = components.libp2p.pubsub
+    this.pubsub = components.libp2p.services.pubsub
 
     this.pubsub.addEventListener('message', (evt) => {
       const message = evt.detail

package/src/utils/resolve-dns-link.browser.ts

@@ -1,7 +1,7 @@
 /* eslint-env browser */
 
-import { TLRU } from './tlru.js'
 import PQueue from 'p-queue'
+import { TLRU } from './tlru.js'
 import type { AbortOptions } from '@libp2p/interfaces'
 
 // Avoid sending multiple queries for the same hostname by caching results
@@ -57,5 +57,5 @@ export async function resolveDnslink (fqdn: string, opts: ResolveDnsLinkOptions
     return ipfsPath(response)
   }
 
-  return await resolve(fqdn, opts)
+  return resolve(fqdn, opts)
 }

package/src/utils/resolve-dns-link.ts

@@ -1,12 +1,12 @@
 import dns from 'dns'
 import { promisify } from 'util'
-import type { AbortOptions } from '@libp2p/interfaces'
 import * as isIPFS from 'is-ipfs'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const MAX_RECURSIVE_DEPTH = 32
 
 export async function resolveDnslink (domain: string, options: AbortOptions = {}): Promise<string> {
-  return await recursiveResolveDnslink(domain, MAX_RECURSIVE_DEPTH, options)
+  return recursiveResolveDnslink(domain, MAX_RECURSIVE_DEPTH, options)
 }
 
 async function recursiveResolveDnslink (domain: string, depth: number, options: AbortOptions = {}): Promise<string> {
@@ -44,7 +44,7 @@ async function recursiveResolveDnslink (domain: string, depth: number, options:
     return result
   }
 
-  return await recursiveResolveDnslink(domainOrCID, depth - 1, options)
+  return recursiveResolveDnslink(domainOrCID, depth - 1, options)
 }
 
 async function resolve (domain: string, options: AbortOptions = {}): Promise<string> {