@libp2p/peer-store 11.2.2-5b004c0c4 → 11.2.2-8e87be9e6

package/src/store.ts

@@ -1,4 +1,5 @@
 import { NotFoundError } from '@libp2p/interface'
+import { PeerMap, trackedPeerMap } from '@libp2p/peer-collections'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import mortice from 'mortice'
 import { base32 } from 'multiformats/bases/base32'
@@ -13,7 +14,7 @@ import type { AddressFilter, PersistentPeerStoreComponents, PersistentPeerStoreI
 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'
+import type { Mortice, Release } from 'mortice'
 
 /**
  * Event detail emitted when peer data changes
@@ -53,10 +54,15 @@ function mapQuery (query: PeerQuery, maxAddressAge: number): Query {
   }
 }
 
+export interface Lock {
+  refs: number
+  lock: Mortice
+}
+
 export class PersistentStore {
   private readonly peerId: PeerId
   private readonly datastore: Datastore
-  public readonly lock: Mortice
+  private locks: PeerMap<Lock>
   private readonly addressFilter?: AddressFilter
   private readonly log: Logger
   private readonly maxAddressAge: number
@@ -67,14 +73,77 @@ export class PersistentStore {
     this.peerId = components.peerId
     this.datastore = components.datastore
     this.addressFilter = init.addressFilter
-    this.lock = mortice({
-      name: 'peer-store',
-      singleProcess: true
+    this.locks = trackedPeerMap({
+      name: 'libp2p_peer_store_locks',
+      metrics: components.metrics
     })
     this.maxAddressAge = init.maxAddressAge ?? MAX_ADDRESS_AGE
     this.maxPeerAge = init.maxPeerAge ?? MAX_PEER_AGE
   }
 
+  getLock (peerId: PeerId): Lock {
+    let lock = this.locks.get(peerId)
+
+    if (lock == null) {
+      lock = {
+        refs: 0,
+        lock: mortice({
+          name: peerId.toString(),
+          singleProcess: true
+        })
+      }
+
+      this.locks.set(peerId, lock)
+    }
+
+    lock.refs++
+
+    return lock
+  }
+
+  private maybeRemoveLock (peerId: PeerId, lock: Lock): void {
+    lock.refs--
+
+    if (lock.refs === 0) {
+      lock.lock.finalize()
+      this.locks.delete(peerId)
+    }
+  }
+
+  async getReadLock (peerId: PeerId, options?: AbortOptions): Promise<Release> {
+    const lock = this.getLock(peerId)
+
+    try {
+      const release = await lock.lock.readLock(options)
+
+      return () => {
+        release()
+        this.maybeRemoveLock(peerId, lock)
+      }
+    } catch (err) {
+      this.maybeRemoveLock(peerId, lock)
+
+      throw err
+    }
+  }
+
+  async getWriteLock (peerId: PeerId, options?: AbortOptions): Promise<Release> {
+    const lock = this.getLock(peerId)
+
+    try {
+      const release = await lock.lock.writeLock(options)
+
+      return () => {
+        release()
+        this.maybeRemoveLock(peerId, lock)
+      }
+    } catch (err) {
+      this.maybeRemoveLock(peerId, lock)
+
+      throw err
+    }
+  }
+
   async has (peerId: PeerId, options?: AbortOptions): Promise<boolean> {
     try {
       await this.load(peerId, options)
@@ -179,7 +248,7 @@ export class PersistentStore {
 
       return {
         peerPB,
-        peer: bytesToPeer(peerId, buf, this.maxAddressAge)
+        peer: pbToPeer(peerId, peerPB, this.maxAddressAge)
       }
     } catch (err: any) {
       if (err.name !== 'NotFoundError') {
@@ -196,7 +265,7 @@ export class PersistentStore {
     await this.datastore.put(peerIdToDatastoreKey(peerId), buf, options)
 
     return {
-      peer: bytesToPeer(peerId, buf, this.maxAddressAge),
+      peer: pbToPeer(peerId, peer, this.maxAddressAge),
       previous: existingPeer?.peer,
       updated: existingPeer == null || !peerEquals(peer, existingPeer.peerPB)
     }

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

@@ -1,22 +1,20 @@
 import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
 import { peerIdFromPublicKey } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
-import { base58btc } from 'multiformats/bases/base58'
-import * as Digest from 'multiformats/hashes/digest'
 import { Peer as PeerPB } from '../pb/peer.js'
 import type { PeerId, Peer, Tag } from '@libp2p/interface'
+import type { Digest } from 'multiformats/hashes/digest'
 
 function populatePublicKey (peerId: PeerId, protobuf: PeerPB): PeerId {
   if (peerId.publicKey != null || protobuf.publicKey == null) {
     return peerId
   }
 
-  let digest: any
+  let digest: Digest<18, number> | undefined
 
   if (peerId.type === 'RSA') {
     // avoid hashing public key
-    const multihash = base58btc.decode(`z${peerId}`)
-    digest = Digest.decode(multihash)
+    digest = peerId.toMultihash()
   }
 
   const publicKey = publicKeyFromProtobuf(protobuf.publicKey, digest)

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

@@ -252,8 +252,13 @@ function mapTag (key: string, tag: any): Tag {
     expiry = BigInt(Date.now() + Number(tag.ttl))
   }
 
-  return {
-    value: tag.value ?? 0,
-    expiry
+  const output: Tag = {
+    value: tag.value ?? 0
   }
+
+  if (expiry != null) {
+    output.expiry = expiry
+  }
+
+  return output
 }