@libp2p/peer-store 9.0.9 → 9.0.10

package/src/index.ts

@@ -1,20 +1,15 @@
-import { logger } from '@libp2p/logger'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import all from 'it-all'
 import { PersistentStore, type PeerUpdate } from './store.js'
-import type { Libp2pEvents } from '@libp2p/interface'
-import type { TypedEventTarget } from '@libp2p/interface/events'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerStore, Peer, PeerData, PeerQuery } from '@libp2p/interface/peer-store'
+import type { ComponentLogger, Libp2pEvents, Logger, TypedEventTarget, PeerId, PeerStore, Peer, PeerData, PeerQuery } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Datastore } from 'interface-datastore'
 
-const log = logger('libp2p:peer-store')
-
 export interface PersistentPeerStoreComponents {
   peerId: PeerId
   datastore: Datastore
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**
@@ -35,84 +30,86 @@ export class PersistentPeerStore implements PeerStore {
   private readonly store: PersistentStore
   private readonly events: TypedEventTarget<Libp2pEvents>
   private readonly peerId: PeerId
+  private readonly log: Logger
 
   constructor (components: PersistentPeerStoreComponents, init: PersistentPeerStoreInit = {}) {
+    this.log = components.logger.forComponent('libp2p:peer-store')
     this.events = components.events
     this.peerId = components.peerId
     this.store = new PersistentStore(components, init)
   }
 
   async forEach (fn: (peer: Peer,) => void, query?: PeerQuery): Promise<void> {
-    log.trace('forEach await read lock')
+    this.log.trace('forEach await read lock')
     const release = await this.store.lock.readLock()
-    log.trace('forEach got read lock')
+    this.log.trace('forEach got read lock')
 
     try {
       for await (const peer of this.store.all(query)) {
         fn(peer)
       }
     } finally {
-      log.trace('forEach release read lock')
+      this.log.trace('forEach release read lock')
       release()
     }
   }
 
   async all (query?: PeerQuery): Promise<Peer[]> {
-    log.trace('all await read lock')
+    this.log.trace('all await read lock')
     const release = await this.store.lock.readLock()
-    log.trace('all got read lock')
+    this.log.trace('all got read lock')
 
     try {
       return await all(this.store.all(query))
     } finally {
-      log.trace('all release read lock')
+      this.log.trace('all release read lock')
       release()
     }
   }
 
   async delete (peerId: PeerId): Promise<void> {
-    log.trace('delete await write lock')
+    this.log.trace('delete await write lock')
     const release = await this.store.lock.writeLock()
-    log.trace('delete got write lock')
+    this.log.trace('delete got write lock')
 
     try {
       await this.store.delete(peerId)
     } finally {
-      log.trace('delete release write lock')
+      this.log.trace('delete release write lock')
       release()
     }
   }
 
   async has (peerId: PeerId): Promise<boolean> {
-    log.trace('has await read lock')
+    this.log.trace('has await read lock')
     const release = await this.store.lock.readLock()
-    log.trace('has got read lock')
+    this.log.trace('has got read lock')
 
     try {
       return await this.store.has(peerId)
     } finally {
-      log.trace('has release read lock')
+      this.log.trace('has release read lock')
       release()
     }
   }
 
   async get (peerId: PeerId): Promise<Peer> {
-    log.trace('get await read lock')
+    this.log.trace('get await read lock')
     const release = await this.store.lock.readLock()
-    log.trace('get got read lock')
+    this.log.trace('get got read lock')
 
     try {
       return await this.store.load(peerId)
     } finally {
-      log.trace('get release read lock')
+      this.log.trace('get release read lock')
       release()
     }
   }
 
   async save (id: PeerId, data: PeerData): Promise<Peer> {
-    log.trace('save await write lock')
+    this.log.trace('save await write lock')
     const release = await this.store.lock.writeLock()
-    log.trace('save got write lock')
+    this.log.trace('save got write lock')
 
     try {
       const result = await this.store.save(id, data)
@@ -121,15 +118,15 @@ export class PersistentPeerStore implements PeerStore {
 
       return result.peer
     } finally {
-      log.trace('save release write lock')
+      this.log.trace('save release write lock')
       release()
     }
   }
 
   async patch (id: PeerId, data: PeerData): Promise<Peer> {
-    log.trace('patch await write lock')
+    this.log.trace('patch await write lock')
     const release = await this.store.lock.writeLock()
-    log.trace('patch got write lock')
+    this.log.trace('patch got write lock')
 
     try {
       const result = await this.store.patch(id, data)
@@ -138,15 +135,15 @@ export class PersistentPeerStore implements PeerStore {
 
       return result.peer
     } finally {
-      log.trace('patch release write lock')
+      this.log.trace('patch release write lock')
       release()
     }
   }
 
   async merge (id: PeerId, data: PeerData): Promise<Peer> {
-    log.trace('merge await write lock')
+    this.log.trace('merge await write lock')
     const release = await this.store.lock.writeLock()
-    log.trace('merge got write lock')
+    this.log.trace('merge got write lock')
 
     try {
       const result = await this.store.merge(id, data)
@@ -155,7 +152,7 @@ export class PersistentPeerStore implements PeerStore {
 
       return result.peer
     } finally {
-      log.trace('merge release write lock')
+      this.log.trace('merge release write lock')
       release()
     }
   }
@@ -164,7 +161,7 @@ export class PersistentPeerStore implements PeerStore {
     const envelope = await RecordEnvelope.openAndCertify(buf, PeerRecord.DOMAIN)
 
     if (expectedPeer?.equals(envelope.peerId) === false) {
-      log('envelope peer id was not the expected peer id - expected: %p received: %p', expectedPeer, envelope.peerId)
+      this.log('envelope peer id was not the expected peer id - expected: %p received: %p', expectedPeer, envelope.peerId)
       return false
     }
 
@@ -185,7 +182,7 @@ export class PersistentPeerStore implements PeerStore {
       const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
 
       if (storedRecord.seqNumber >= peerRecord.seqNumber) {
-        log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
+        this.log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
         return false
       }
     }

package/src/store.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import mortice, { type Mortice } from 'mortice'
@@ -10,9 +10,7 @@ import { bytesToPeer } from './utils/bytes-to-peer.js'
 import { NAMESPACE_COMMON, peerIdToDatastoreKey } from './utils/peer-id-to-datastore-key.js'
 import { toPeerPB } from './utils/to-peer-pb.js'
 import type { AddressFilter, PersistentPeerStoreComponents, PersistentPeerStoreInit } from './index.js'
-import type { PeerUpdate as PeerUpdateExternal } from '@libp2p/interface'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Peer, PeerData, PeerQuery } from '@libp2p/interface/peer-store'
+import type { PeerUpdate as PeerUpdateExternal, PeerId, Peer, PeerData, PeerQuery } from '@libp2p/interface'
 import type { Datastore, Key, Query } from 'interface-datastore'
 
 /**

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

@@ -1,8 +1,7 @@
 import { peerIdFromPeerId } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Peer, Tag } from '@libp2p/interface/peer-store'
+import type { PeerId, Peer, Tag } from '@libp2p/interface'
 
 export function bytesToPeer (peerId: PeerId, buf: Uint8Array): Peer {
   const peer = PeerPB.decode(buf)

package/src/utils/dedupe-addresses.ts

@@ -1,10 +1,9 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
 import { codes } from '../errors.js'
 import type { AddressFilter } from '../index.js'
 import type { Address as AddressPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Address } from '@libp2p/interface/peer-store'
+import type { PeerId, Address } from '@libp2p/interface'
 
 export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: AddressFilter, addresses: Array<Address | AddressPB | undefined>): Promise<AddressPB[]> {
   const addressMap = new Map<string, Address>()

package/src/utils/peer-data-to-datastore-peer.ts

@@ -1,10 +1,9 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { isMultiaddr } from '@multiformats/multiaddr'
 import { equals as uint8arrayEquals } from 'uint8arrays/equals'
 import { codes } from '../errors.js'
 import type { Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerData } from '@libp2p/interface/peer-store'
+import type { PeerId, PeerData } from '@libp2p/interface'
 
 export function toDatastorePeer (peerId: PeerId, data: PeerData): PeerPB {
   if (data == null) {

package/src/utils/peer-id-to-datastore-key.ts

@@ -1,5 +1,5 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { isPeerId, type PeerId } from '@libp2p/interface/peer-id'
+import { CodeError } from '@libp2p/interface'
+import { isPeerId, type PeerId } from '@libp2p/interface'
 import { Key } from 'interface-datastore/key'
 import { codes } from '../errors.js'
 

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

@@ -1,11 +1,10 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { equals as uint8arrayEquals } from 'uint8arrays/equals'
 import { codes } from '../errors.js'
 import { dedupeFilterAndSortAddresses } from './dedupe-addresses.js'
 import type { AddressFilter } from '../index.js'
 import type { Tag, Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Address, Peer, PeerData, TagOptions } from '@libp2p/interface/peer-store'
+import type { PeerId, Address, Peer, PeerData, TagOptions } from '@libp2p/interface'
 
 export interface ToPBPeerOptions {
   addressFilter?: AddressFilter