@libp2p/peer-record 7.0.25-dd7b329c4 → 7.0.25-e1ca9cced

package/src/envelope/envelope.ts

@@ -4,8 +4,8 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, message } from 'protons-runtime'
+import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Envelope {
@@ -48,12 +48,12 @@ export namespace Envelope {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
-          publicKey: new Uint8Array(0),
-          payloadType: new Uint8Array(0),
-          payload: new Uint8Array(0),
-          signature: new Uint8Array(0)
+          publicKey: uint8ArrayAlloc(0),
+          payloadType: uint8ArrayAlloc(0),
+          payload: uint8ArrayAlloc(0),
+          signature: uint8ArrayAlloc(0)
         }
 
         const end = length == null ? reader.len : reader.pos + length
@@ -62,21 +62,26 @@ export namespace Envelope {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.publicKey = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
               obj.payloadType = reader.bytes()
               break
-            case 3:
+            }
+            case 3: {
               obj.payload = reader.bytes()
               break
-            case 5:
+            }
+            case 5: {
               obj.signature = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -91,7 +96,7 @@ export namespace Envelope {
     return encodeMessage(obj, Envelope.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Envelope => {
-    return decodeMessage(buf, Envelope.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Envelope>): Envelope => {
+    return decodeMessage(buf, Envelope.codec(), opts)
   }
 }

package/src/envelope/errors.ts

@@ -0,0 +1,9 @@
+/**
+ * The key in the record is not valid for the domain
+ */
+export class InvalidSignatureError extends Error {
+  constructor (message = 'Invalid signature') {
+    super(message)
+    this.name = 'InvalidSignatureError'
+  }
+}

package/src/envelope/index.ts

@@ -1,16 +1,14 @@
-import { unmarshalPrivateKey, unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { CodeError } from '@libp2p/interface'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import * as varint from 'uint8-varint'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8arraysFromString } from 'uint8arrays/from-string'
-import { codes } from '../errors.js'
 import { Envelope as Protobuf } from './envelope.js'
-import type { PeerId, Record, Envelope } from '@libp2p/interface'
+import { InvalidSignatureError } from './errors.js'
+import type { Record, Envelope, PrivateKey, PublicKey } from '@libp2p/interface'
 
 export interface RecordEnvelopeInit {
-  peerId: PeerId
+  publicKey: PublicKey
   payloadType: Uint8Array
   payload: Uint8Array
   signature: Uint8Array
@@ -22,10 +20,10 @@ export class RecordEnvelope implements Envelope {
    */
   static createFromProtobuf = async (data: Uint8Array | Uint8ArrayList): Promise<RecordEnvelope> => {
     const envelopeData = Protobuf.decode(data)
-    const peerId = await peerIdFromKeys(envelopeData.publicKey)
+    const publicKey = publicKeyFromProtobuf(envelopeData.publicKey)
 
     return new RecordEnvelope({
-      peerId,
+      publicKey,
       payloadType: envelopeData.payloadType,
       payload: envelopeData.payload,
       signature: envelopeData.signature
@@ -36,8 +34,8 @@ export class RecordEnvelope implements Envelope {
    * Seal marshals the given Record, places the marshaled bytes inside an Envelope
    * and signs it with the given peerId's private key
    */
-  static seal = async (record: Record, peerId: PeerId): Promise<RecordEnvelope> => {
-    if (peerId.privateKey == null) {
+  static seal = async (record: Record, privateKey: PrivateKey): Promise<RecordEnvelope> => {
+    if (privateKey == null) {
       throw new Error('Missing private key')
     }
 
@@ -45,11 +43,10 @@ export class RecordEnvelope implements Envelope {
     const payloadType = record.codec
     const payload = record.marshal()
     const signData = formatSignaturePayload(domain, payloadType, payload)
-    const key = await unmarshalPrivateKey(peerId.privateKey)
-    const signature = await key.sign(signData.subarray())
+    const signature = await privateKey.sign(signData.subarray())
 
     return new RecordEnvelope({
-      peerId,
+      publicKey: privateKey.publicKey,
       payloadType,
       payload,
       signature
@@ -65,13 +62,13 @@ export class RecordEnvelope implements Envelope {
     const valid = await envelope.validate(domain)
 
     if (!valid) {
-      throw new CodeError('envelope signature is not valid for the given domain', codes.ERR_SIGNATURE_NOT_VALID)
+      throw new InvalidSignatureError('Envelope signature is not valid for the given domain')
     }
 
     return envelope
   }
 
-  public peerId: PeerId
+  public publicKey: PublicKey
   public payloadType: Uint8Array
   public payload: Uint8Array
   public signature: Uint8Array
@@ -82,9 +79,9 @@ export class RecordEnvelope implements Envelope {
    * by a libp2p peer.
    */
   constructor (init: RecordEnvelopeInit) {
-    const { peerId, payloadType, payload, signature } = init
+    const { publicKey, payloadType, payload, signature } = init
 
-    this.peerId = peerId
+    this.publicKey = publicKey
     this.payloadType = payloadType
     this.payload = payload
     this.signature = signature
@@ -94,13 +91,9 @@ export class RecordEnvelope implements Envelope {
    * Marshal the envelope content
    */
   marshal (): Uint8Array {
-    if (this.peerId.publicKey == null) {
-      throw new Error('Missing public key')
-    }
-
     if (this.marshaled == null) {
       this.marshaled = Protobuf.encode({
-        publicKey: this.peerId.publicKey,
+        publicKey: publicKeyToProtobuf(this.publicKey),
         payloadType: this.payloadType,
         payload: this.payload.subarray(),
         signature: this.signature
@@ -123,13 +116,7 @@ export class RecordEnvelope implements Envelope {
   async validate (domain: string): Promise<boolean> {
     const signData = formatSignaturePayload(domain, this.payloadType, this.payload)
 
-    if (this.peerId.publicKey == null) {
-      throw new Error('Missing public key')
-    }
-
-    const key = unmarshalPublicKey(this.peerId.publicKey)
-
-    return key.verify(signData.subarray(), this.signature)
+    return this.publicKey.verify(signData.subarray(), this.signature)
   }
 }
 

package/src/index.ts

@@ -17,16 +17,18 @@
  *
  * ```TypeScript
  * import { PeerRecord, RecordEnvelope } from '@libp2p/peer-record'
- * import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+ * import { generateKeyPair } from '@libp2p/crypto/keys'
+ * import { peerIdFromPrivateKey } from '@libp2p/peer-id'
  *
- * const peerId = await createEd25519PeerId()
+ * const privateKey = await generateKeyPair('Ed25519')
+ * const peerId = peerIdFromPrivateKey(privateKey)
  *
  * const record = new PeerRecord({
- *   peerId,
+ *    peerId,
  *   // ...other data
  * })
  *
- * const envelope = await RecordEnvelope.seal(record, peerId)
+ * const envelope = await RecordEnvelope.seal(record, privateKey)
  * const wireData = envelope.marshal()
  * ```
  *
@@ -59,10 +61,11 @@
  *
  * ```TypeScript
  * import { PeerRecord } from '@libp2p/peer-record'
- * import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+ * import { peerIdFromPrivateKey } from '@libp2p/peer-id'
+import { generateKeyPair } from '@libp2p/crypto/keys'
  * import { multiaddr } from '@multiformats/multiaddr'
  *
- * const peerId = await createEd25519PeerId()
+ * const peerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
  *
  * const record = new PeerRecord({
  *   peerId: peerId,

package/src/peer-record/index.ts

@@ -1,6 +1,7 @@
-import { peerIdFromBytes } from '@libp2p/peer-id'
+import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { arrayEquals } from '@libp2p/utils/array-equals'
 import { multiaddr } from '@multiformats/multiaddr'
+import * as Digest from 'multiformats/hashes/digest'
 import {
   ENVELOPE_DOMAIN_PEER_RECORD,
   ENVELOPE_PAYLOAD_TYPE_PEER_RECORD
@@ -34,7 +35,7 @@ export class PeerRecord {
    */
   static createFromProtobuf = (buf: Uint8Array | Uint8ArrayList): PeerRecord => {
     const peerRecord = Protobuf.decode(buf)
-    const peerId = peerIdFromBytes(peerRecord.peerId)
+    const peerId = peerIdFromMultihash(Digest.decode(peerRecord.peerId))
     const multiaddrs = (peerRecord.addresses ?? []).map((a) => multiaddr(a.multiaddr))
     const seqNumber = peerRecord.seq
 
@@ -65,7 +66,7 @@ export class PeerRecord {
   marshal (): Uint8Array {
     if (this.marshaled == null) {
       this.marshaled = Protobuf.encode({
-        peerId: this.peerId.toBytes(),
+        peerId: this.peerId.toMultihash().bytes,
         seq: BigInt(this.seqNumber),
         addresses: this.multiaddrs.map((m) => ({
           multiaddr: m.bytes

package/src/peer-record/peer-record.ts

@@ -4,8 +4,8 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, MaxLengthError, message } from 'protons-runtime'
+import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface PeerRecord {
@@ -37,9 +37,9 @@ export namespace PeerRecord {
           if (opts.lengthDelimited !== false) {
             w.ldelim()
           }
-        }, (reader, length) => {
+        }, (reader, length, opts = {}) => {
           const obj: any = {
-            multiaddr: new Uint8Array(0)
+            multiaddr: uint8ArrayAlloc(0)
           }
 
           const end = length == null ? reader.len : reader.pos + length
@@ -48,12 +48,14 @@ export namespace PeerRecord {
             const tag = reader.uint32()
 
             switch (tag >>> 3) {
-              case 1:
+              case 1: {
                 obj.multiaddr = reader.bytes()
                 break
-              default:
+              }
+              default: {
                 reader.skipType(tag & 7)
                 break
+              }
             }
           }
 
@@ -68,8 +70,8 @@ export namespace PeerRecord {
       return encodeMessage(obj, AddressInfo.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList): AddressInfo => {
-      return decodeMessage(buf, AddressInfo.codec())
+    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<AddressInfo>): AddressInfo => {
+      return decodeMessage(buf, AddressInfo.codec(), opts)
     }
   }
 
@@ -102,9 +104,9 @@ export namespace PeerRecord {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
-          peerId: new Uint8Array(0),
+          peerId: uint8ArrayAlloc(0),
           seq: 0n,
           addresses: []
         }
@@ -115,18 +117,28 @@ export namespace PeerRecord {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.peerId = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
               obj.seq = reader.uint64()
               break
-            case 3:
-              obj.addresses.push(PeerRecord.AddressInfo.codec().decode(reader, reader.uint32()))
+            }
+            case 3: {
+              if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) {
+                throw new MaxLengthError('Decode error - map field "addresses" had too many elements')
+              }
+
+              obj.addresses.push(PeerRecord.AddressInfo.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.addresses$
+              }))
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -141,7 +153,7 @@ export namespace PeerRecord {
     return encodeMessage(obj, PeerRecord.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerRecord => {
-    return decodeMessage(buf, PeerRecord.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerRecord>): PeerRecord => {
+    return decodeMessage(buf, PeerRecord.codec(), opts)
   }
 }

package/dist/src/errors.d.ts

@@ -1,4 +0,0 @@
-export declare const codes: {
-    ERR_SIGNATURE_NOT_VALID: string;
-};
-//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;;CAEjB,CAAA"}

package/dist/src/errors.js

@@ -1,4 +0,0 @@
-export const codes = {
-    ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
-};
-//# sourceMappingURL=errors.js.map

package/dist/src/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,uBAAuB,EAAE,yBAAyB;CACnD,CAAA"}

package/src/errors.ts

@@ -1,3 +0,0 @@
-export const codes = {
-  ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
-}