@libp2p/peer-store 11.2.1 → 11.2.2-3528df829

package/src/index.ts

@@ -4,12 +4,13 @@
  * The peer store is where libp2p stores data about the peers it has encountered on the network.
  */
 
+import { isPeerId } from '@libp2p/interface'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import all from 'it-all'
 import { PersistentStore } from './store.js'
 import type { PeerUpdate } from './store.js'
-import type { ComponentLogger, Libp2pEvents, Logger, TypedEventTarget, PeerId, PeerStore, Peer, PeerData, PeerQuery, PeerInfo } from '@libp2p/interface'
+import type { ComponentLogger, Libp2pEvents, Logger, TypedEventTarget, PeerId, PeerStore, Peer, PeerData, PeerQuery, PeerInfo, AbortOptions, ConsumePeerRecordOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Datastore } from 'interface-datastore'
 
@@ -24,7 +25,7 @@ export interface PersistentPeerStoreComponents {
  * Return true to allow storing the passed multiaddr for the passed peer
  */
 export interface AddressFilter {
-  (peerId: PeerId, multiaddr: Multiaddr): Promise<boolean> | boolean
+  (peerId: PeerId, multiaddr: Multiaddr, options?: AbortOptions): Promise<boolean> | boolean
 }
 
 export interface PersistentPeerStoreInit {
@@ -74,74 +75,60 @@ class PersistentPeerStore implements PeerStore {
   readonly [Symbol.toStringTag] = '@libp2p/peer-store'
 
   async forEach (fn: (peer: Peer,) => void, query?: PeerQuery): Promise<void> {
-    this.log.trace('forEach await read lock')
-    const release = await this.store.lock.readLock()
-    this.log.trace('forEach got read lock')
+    const release = await this.store.lock.readLock(query)
 
     try {
       for await (const peer of this.store.all(query)) {
         fn(peer)
       }
     } finally {
-      this.log.trace('forEach release read lock')
       release()
     }
   }
 
   async all (query?: PeerQuery): Promise<Peer[]> {
-    this.log.trace('all await read lock')
-    const release = await this.store.lock.readLock()
-    this.log.trace('all got read lock')
+    const release = await this.store.lock.readLock(query)
 
     try {
       return await all(this.store.all(query))
     } finally {
-      this.log.trace('all release read lock')
       release()
     }
   }
 
-  async delete (peerId: PeerId): Promise<void> {
-    this.log.trace('delete await write lock')
-    const release = await this.store.lock.writeLock()
-    this.log.trace('delete got write lock')
+  async delete (peerId: PeerId, options?: AbortOptions): Promise<void> {
+    const release = await this.store.lock.writeLock(options)
 
     try {
-      await this.store.delete(peerId)
+      await this.store.delete(peerId, options)
     } finally {
-      this.log.trace('delete release write lock')
       release()
     }
   }
 
-  async has (peerId: PeerId): Promise<boolean> {
-    this.log.trace('has await read lock')
-    const release = await this.store.lock.readLock()
-    this.log.trace('has got read lock')
+  async has (peerId: PeerId, options?: AbortOptions): Promise<boolean> {
+    const release = await this.store.lock.readLock(options)
 
     try {
-      return await this.store.has(peerId)
+      return await this.store.has(peerId, options)
     } finally {
       this.log.trace('has release read lock')
       release()
     }
   }
 
-  async get (peerId: PeerId): Promise<Peer> {
-    this.log.trace('get await read lock')
-    const release = await this.store.lock.readLock()
-    this.log.trace('get got read lock')
+  async get (peerId: PeerId, options?: AbortOptions): Promise<Peer> {
+    const release = await this.store.lock.readLock(options)
 
     try {
-      return await this.store.load(peerId)
+      return await this.store.load(peerId, options)
     } finally {
-      this.log.trace('get release read lock')
       release()
     }
   }
 
-  async getInfo (peerId: PeerId): Promise<PeerInfo> {
-    const peer = await this.get(peerId)
+  async getInfo (peerId: PeerId, options?: AbortOptions): Promise<PeerInfo> {
+    const peer = await this.get(peerId, options)
 
     return {
       id: peer.id,
@@ -149,59 +136,55 @@ class PersistentPeerStore implements PeerStore {
     }
   }
 
-  async save (id: PeerId, data: PeerData): Promise<Peer> {
-    this.log.trace('save await write lock')
-    const release = await this.store.lock.writeLock()
-    this.log.trace('save got write lock')
+  async save (id: PeerId, data: PeerData, options?: AbortOptions): Promise<Peer> {
+    const release = await this.store.lock.writeLock(options)
 
     try {
-      const result = await this.store.save(id, data)
+      const result = await this.store.save(id, data, options)
 
       this.#emitIfUpdated(id, result)
 
       return result.peer
     } finally {
-      this.log.trace('save release write lock')
       release()
     }
   }
 
-  async patch (id: PeerId, data: PeerData): Promise<Peer> {
-    this.log.trace('patch await write lock')
-    const release = await this.store.lock.writeLock()
-    this.log.trace('patch got write lock')
+  async patch (id: PeerId, data: PeerData, options?: AbortOptions): Promise<Peer> {
+    const release = await this.store.lock.writeLock(options)
 
     try {
-      const result = await this.store.patch(id, data)
+      const result = await this.store.patch(id, data, options)
 
       this.#emitIfUpdated(id, result)
 
       return result.peer
     } finally {
-      this.log.trace('patch release write lock')
       release()
     }
   }
 
-  async merge (id: PeerId, data: PeerData): Promise<Peer> {
-    this.log.trace('merge await write lock')
-    const release = await this.store.lock.writeLock()
-    this.log.trace('merge got write lock')
+  async merge (id: PeerId, data: PeerData, options?: AbortOptions): Promise<Peer> {
+    const release = await this.store.lock.writeLock(options)
 
     try {
-      const result = await this.store.merge(id, data)
+      const result = await this.store.merge(id, data, options)
 
       this.#emitIfUpdated(id, result)
 
       return result.peer
     } finally {
-      this.log.trace('merge release write lock')
       release()
     }
   }
 
-  async consumePeerRecord (buf: Uint8Array, expectedPeer?: PeerId): Promise<boolean> {
-    const envelope = await RecordEnvelope.openAndCertify(buf, PeerRecord.DOMAIN)
+  async consumePeerRecord (buf: Uint8Array, options?: ConsumePeerRecordOptions): Promise<boolean>
+  async consumePeerRecord (buf: Uint8Array, expectedPeer?: PeerId, options?: AbortOptions): Promise<boolean>
+  async consumePeerRecord (buf: Uint8Array, arg1?: any, arg2?: any): Promise<boolean> {
+    const expectedPeer: PeerId | undefined = isPeerId(arg1) ? arg1 : isPeerId(arg1?.expectedPeer) ? arg1.expectedPeer : undefined
+    const options: AbortOptions | undefined = isPeerId(arg1) ? arg2 : arg1 === undefined ? arg2 : arg1
+
+    const envelope = await RecordEnvelope.openAndCertify(buf, PeerRecord.DOMAIN, options)
     const peerId = peerIdFromCID(envelope.publicKey.toCID())
 
     if (expectedPeer?.equals(peerId) === false) {
@@ -213,7 +196,7 @@ class PersistentPeerStore implements PeerStore {
     let peer: Peer | undefined
 
     try {
-      peer = await this.get(peerId)
+      peer = await this.get(peerId, options)
     } catch (err: any) {
       if (err.name !== 'NotFoundError') {
         throw err
@@ -222,7 +205,7 @@ class PersistentPeerStore implements PeerStore {
 
     // ensure seq is greater than, or equal to, the last received
     if (peer?.peerRecordEnvelope != null) {
-      const storedEnvelope = await RecordEnvelope.createFromProtobuf(peer.peerRecordEnvelope)
+      const storedEnvelope = RecordEnvelope.createFromProtobuf(peer.peerRecordEnvelope)
       const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
 
       if (storedRecord.seqNumber >= peerRecord.seqNumber) {
@@ -237,7 +220,7 @@ class PersistentPeerStore implements PeerStore {
         isCertified: true,
         multiaddr
       }))
-    })
+    }, options)
 
     return true
   }

package/src/store.ts

@@ -11,6 +11,7 @@ import { NAMESPACE_COMMON, peerIdToDatastoreKey } from './utils/peer-id-to-datas
 import { toPeerPB } from './utils/to-peer-pb.js'
 import type { AddressFilter, PersistentPeerStoreComponents, PersistentPeerStoreInit } from './index.js'
 import type { PeerUpdate as PeerUpdateExternal, PeerId, Peer, PeerData, PeerQuery, Logger } from '@libp2p/interface'
+import type { AbortOptions } from '@multiformats/multiaddr'
 import type { Datastore, Key, Query } from 'interface-datastore'
 import type { Mortice } from 'mortice'
 
@@ -74,9 +75,9 @@ export class PersistentStore {
     this.maxPeerAge = init.maxPeerAge ?? MAX_PEER_AGE
   }
 
-  async has (peerId: PeerId): Promise<boolean> {
+  async has (peerId: PeerId, options?: AbortOptions): Promise<boolean> {
     try {
-      await this.load(peerId)
+      await this.load(peerId, options)
 
       return true
     } catch (err: any) {
@@ -88,41 +89,43 @@ export class PersistentStore {
     return false
   }
 
-  async delete (peerId: PeerId): Promise<void> {
+  async delete (peerId: PeerId, options?: AbortOptions): Promise<void> {
     if (this.peerId.equals(peerId)) {
       return
     }
 
-    await this.datastore.delete(peerIdToDatastoreKey(peerId))
+    await this.datastore.delete(peerIdToDatastoreKey(peerId), options)
   }
 
-  async load (peerId: PeerId): Promise<Peer> {
+  async load (peerId: PeerId, options?: AbortOptions): Promise<Peer> {
     const key = peerIdToDatastoreKey(peerId)
-    const buf = await this.datastore.get(key)
+    const buf = await this.datastore.get(key, options)
     const peer = PeerPB.decode(buf)
 
     if (this.#peerIsExpired(peerId, peer)) {
-      await this.datastore.delete(key)
+      await this.datastore.delete(key, options)
       throw new NotFoundError()
     }
 
     return pbToPeer(peerId, peer, this.peerId.equals(peerId) ? Infinity : this.maxAddressAge)
   }
 
-  async save (peerId: PeerId, data: PeerData): Promise<PeerUpdate> {
-    const existingPeer = await this.#findExistingPeer(peerId)
+  async save (peerId: PeerId, data: PeerData, options?: AbortOptions): Promise<PeerUpdate> {
+    const existingPeer = await this.#findExistingPeer(peerId, options)
 
     const peerPb: PeerPB = await toPeerPB(peerId, data, 'patch', {
+      ...options,
       addressFilter: this.addressFilter
     })
 
     return this.#saveIfDifferent(peerId, peerPb, existingPeer)
   }
 
-  async patch (peerId: PeerId, data: Partial<PeerData>): Promise<PeerUpdate> {
-    const existingPeer = await this.#findExistingPeer(peerId)
+  async patch (peerId: PeerId, data: Partial<PeerData>, options?: AbortOptions): Promise<PeerUpdate> {
+    const existingPeer = await this.#findExistingPeer(peerId, options)
 
     const peerPb: PeerPB = await toPeerPB(peerId, data, 'patch', {
+      ...options,
       addressFilter: this.addressFilter,
       existingPeer
     })
@@ -130,8 +133,8 @@ export class PersistentStore {
     return this.#saveIfDifferent(peerId, peerPb, existingPeer)
   }
 
-  async merge (peerId: PeerId, data: PeerData): Promise<PeerUpdate> {
-    const existingPeer = await this.#findExistingPeer(peerId)
+  async merge (peerId: PeerId, data: PeerData, options?: AbortOptions): Promise<PeerUpdate> {
+    const existingPeer = await this.#findExistingPeer(peerId, options)
 
     const peerPb: PeerPB = await toPeerPB(peerId, data, 'merge', {
       addressFilter: this.addressFilter,
@@ -141,8 +144,8 @@ export class PersistentStore {
     return this.#saveIfDifferent(peerId, peerPb, existingPeer)
   }
 
-  async * all (query?: PeerQuery): AsyncGenerator<Peer, void, unknown> {
-    for await (const { key, value } of this.datastore.query(mapQuery(query ?? {}, this.maxAddressAge))) {
+  async * all (options?: PeerQuery): AsyncGenerator<Peer, void, unknown> {
+    for await (const { key, value } of this.datastore.query(mapQuery(options ?? {}, this.maxAddressAge), options)) {
       const peerId = keyToPeerId(key)
 
       // skip self peer if present
@@ -154,7 +157,7 @@ export class PersistentStore {
 
       // remove expired peer
       if (this.#peerIsExpired(peerId, peer)) {
-        await this.datastore.delete(key)
+        await this.datastore.delete(key, options)
         continue
       }
 
@@ -162,15 +165,15 @@ export class PersistentStore {
     }
   }
 
-  async #findExistingPeer (peerId: PeerId): Promise<ExistingPeer | undefined> {
+  async #findExistingPeer (peerId: PeerId, options?: AbortOptions): Promise<ExistingPeer | undefined> {
     try {
       const key = peerIdToDatastoreKey(peerId)
-      const buf = await this.datastore.get(key)
+      const buf = await this.datastore.get(key, options)
       const peerPB = PeerPB.decode(buf)
 
       // remove expired peer
       if (this.#peerIsExpired(peerId, peerPB)) {
-        await this.datastore.delete(key)
+        await this.datastore.delete(key, options)
         throw new NotFoundError()
       }
 
@@ -185,12 +188,12 @@ export class PersistentStore {
     }
   }
 
-  async #saveIfDifferent (peerId: PeerId, peer: PeerPB, existingPeer?: ExistingPeer): Promise<PeerUpdate> {
+  async #saveIfDifferent (peerId: PeerId, peer: PeerPB, existingPeer?: ExistingPeer, options?: AbortOptions): Promise<PeerUpdate> {
     // record last update
     peer.updated = Date.now()
     const buf = PeerPB.encode(peer)
 
-    await this.datastore.put(peerIdToDatastoreKey(peerId), buf)
+    await this.datastore.put(peerIdToDatastoreKey(peerId), buf, options)
 
     return {
       peer: bytesToPeer(peerId, buf, this.maxAddressAge),

package/src/utils/dedupe-addresses.ts

@@ -3,8 +3,9 @@ import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
 import type { AddressFilter } from '../index.js'
 import type { Address as AddressPB } from '../pb/peer.js'
 import type { PeerId, Address } from '@libp2p/interface'
+import type { AbortOptions } from '@multiformats/multiaddr'
 
-export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: AddressFilter, addresses: Array<Address | AddressPB | undefined>, existingAddresses?: AddressPB[]): Promise<AddressPB[]> {
+export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: AddressFilter, addresses: Array<Address | AddressPB | undefined>, existingAddresses?: AddressPB[], options?: AbortOptions): Promise<AddressPB[]> {
   const addressMap = new Map<string, Address>()
 
   for (const addr of addresses) {
@@ -20,7 +21,7 @@ export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: Addr
       throw new InvalidParametersError('Multiaddr was invalid')
     }
 
-    if (!(await filter(peerId, addr.multiaddr))) {
+    if (!(await filter(peerId, addr.multiaddr, options))) {
       continue
     }
 

package/src/utils/to-peer-pb.ts

@@ -7,8 +7,9 @@ import type { AddressFilter } from '../index.js'
 import type { Tag, Peer as PeerPB } from '../pb/peer.js'
 import type { ExistingPeer } from '../store.js'
 import type { PeerId, Address, PeerData, TagOptions } from '@libp2p/interface'
+import type { AbortOptions } from '@multiformats/multiaddr'
 
-export interface ToPBPeerOptions {
+export interface ToPBPeerOptions extends AbortOptions {
   addressFilter?: AddressFilter
   existingPeer?: ExistingPeer
 }
@@ -148,7 +149,8 @@ export async function toPeerPB (peerId: PeerId, data: Partial<PeerData>, strateg
       peerId,
       options.addressFilter ?? (async () => true),
       addresses,
-      options.existingPeer?.peerPB.addresses
+      options.existingPeer?.peerPB.addresses,
+      options
     ),
     protocols: [...protocols.values()].sort((a, b) => {
       return a.localeCompare(b)

package/dist/typedoc-urls.json

@@ -1,10 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.AddressFilter.html",
-  ".:AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.AddressFilter.html",
-  "PersistentPeerStoreComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.PersistentPeerStoreComponents.html",
-  ".:PersistentPeerStoreComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.PersistentPeerStoreComponents.html",
-  "PersistentPeerStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.PersistentPeerStoreInit.html",
-  ".:PersistentPeerStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_peer-store.PersistentPeerStoreInit.html",
-  "persistentPeerStore": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer-store.persistentPeerStore.html",
-  ".:persistentPeerStore": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer-store.persistentPeerStore.html"
-}