@libp2p/pubsub 9.0.26-e211b46cc → 10.0.0-1210884ed

package/src/index.ts

@@ -30,23 +30,23 @@
  * ```
  */
 
-import { CodeError, TypedEventEmitter, CustomEvent, TopicValidatorResult } from '@libp2p/interface'
+import { TypedEventEmitter, TopicValidatorResult, InvalidMessageError, NotStartedError, InvalidParametersError } from '@libp2p/interface'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { pipe } from 'it-pipe'
 import Queue from 'p-queue'
-import { codes } from './errors.js'
 import { PeerStreams as PeerStreamsImpl } from './peer-streams.js'
 import {
   signMessage,
   verifySignature
 } from './sign.js'
 import { toMessage, ensureArray, noSignMsgId, msgId, toRpcMessage, randomSeqno } from './utils.js'
-import type { PubSub, Message, StrictNoSign, StrictSign, PubSubInit, PubSubEvents, PeerStreams, PubSubRPCMessage, PubSubRPC, PubSubRPCSubscription, SubscriptionChangeData, PublishResult, TopicValidatorFn, ComponentLogger, Logger, Connection, PeerId } from '@libp2p/interface'
+import type { PubSub, Message, StrictNoSign, StrictSign, PubSubInit, PubSubEvents, PeerStreams, PubSubRPCMessage, PubSubRPC, PubSubRPCSubscription, SubscriptionChangeData, PublishResult, TopicValidatorFn, ComponentLogger, Logger, Connection, PeerId, PrivateKey } from '@libp2p/interface'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface PubSubComponents {
   peerId: PeerId
+  privateKey: PrivateKey
   registrar: Registrar
   logger: ComponentLogger
 }
@@ -261,9 +261,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
    * Registrar notifies a closing connection with pubsub protocol
    */
   protected _onPeerDisconnected (peerId: PeerId, conn?: Connection): void {
-    const idB58Str = peerId.toString()
-
-    this.log('connection ended', idB58Str)
+    this.log('connection ended %p', peerId)
     this._removePeer(peerId)
   }
 
@@ -486,22 +484,22 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     switch (signaturePolicy) {
       case 'StrictSign':
         if (msg.type !== 'signed') {
-          throw new CodeError('Message type should be "signed" when signature policy is StrictSign but it was not', codes.ERR_MISSING_SIGNATURE)
+          throw new InvalidMessageError('Message type should be "signed" when signature policy is StrictSign but it was not')
         }
 
         if (msg.sequenceNumber == null) {
-          throw new CodeError('Need seqno when signature policy is StrictSign but it was missing', codes.ERR_MISSING_SEQNO)
+          throw new InvalidMessageError('Need seqno when signature policy is StrictSign but it was missing')
         }
 
         if (msg.key == null) {
-          throw new CodeError('Need key when signature policy is StrictSign but it was missing', codes.ERR_MISSING_KEY)
+          throw new InvalidMessageError('Need key when signature policy is StrictSign but it was missing')
         }
 
         return msgId(msg.key, msg.sequenceNumber)
       case 'StrictNoSign':
         return noSignMsgId(msg.data)
       default:
-        throw new CodeError('Cannot get message id: unhandled signature policy', codes.ERR_UNHANDLED_SIGNATURE_POLICY)
+        throw new InvalidMessageError('Cannot get message id: unhandled signature policy')
     }
   }
 
@@ -573,51 +571,51 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     switch (signaturePolicy) {
       case 'StrictNoSign':
         if (message.type !== 'unsigned') {
-          throw new CodeError('Message type should be "unsigned" when signature policy is StrictNoSign but it was not', codes.ERR_MISSING_SIGNATURE)
+          throw new InvalidMessageError('Message type should be "unsigned" when signature policy is StrictNoSign but it was not')
         }
 
         // @ts-expect-error should not be present
         if (message.signature != null) {
-          throw new CodeError('StrictNoSigning: signature should not be present', codes.ERR_UNEXPECTED_SIGNATURE)
+          throw new InvalidMessageError('StrictNoSigning: signature should not be present')
         }
 
         // @ts-expect-error should not be present
         if (message.key != null) {
-          throw new CodeError('StrictNoSigning: key should not be present', codes.ERR_UNEXPECTED_KEY)
+          throw new InvalidMessageError('StrictNoSigning: key should not be present')
         }
 
         // @ts-expect-error should not be present
         if (message.sequenceNumber != null) {
-          throw new CodeError('StrictNoSigning: seqno should not be present', codes.ERR_UNEXPECTED_SEQNO)
+          throw new InvalidMessageError('StrictNoSigning: seqno should not be present')
         }
         break
       case 'StrictSign':
         if (message.type !== 'signed') {
-          throw new CodeError('Message type should be "signed" when signature policy is StrictSign but it was not', codes.ERR_MISSING_SIGNATURE)
+          throw new InvalidMessageError('Message type should be "signed" when signature policy is StrictSign but it was not')
         }
 
         if (message.signature == null) {
-          throw new CodeError('StrictSigning: Signing required and no signature was present', codes.ERR_MISSING_SIGNATURE)
+          throw new InvalidMessageError('StrictSigning: Signing required and no signature was present')
         }
 
         if (message.sequenceNumber == null) {
-          throw new CodeError('StrictSigning: Signing required and no sequenceNumber was present', codes.ERR_MISSING_SEQNO)
+          throw new InvalidMessageError('StrictSigning: Signing required and no sequenceNumber was present')
         }
 
         if (!(await verifySignature(message, this.encodeMessage.bind(this)))) {
-          throw new CodeError('StrictSigning: Invalid message signature', codes.ERR_INVALID_SIGNATURE)
+          throw new InvalidMessageError('StrictSigning: Invalid message signature')
         }
 
         break
       default:
-        throw new CodeError('Cannot validate message: unhandled signature policy', codes.ERR_UNHANDLED_SIGNATURE_POLICY)
+        throw new InvalidMessageError('Cannot validate message: unhandled signature policy')
     }
 
     const validatorFn = this.topicValidators.get(message.topic)
     if (validatorFn != null) {
       const result = await validatorFn(from, message)
       if (result === TopicValidatorResult.Reject || result === TopicValidatorResult.Ignore) {
-        throw new CodeError('Message validation failed', codes.ERR_TOPIC_VALIDATOR_REJECT)
+        throw new InvalidMessageError('Message validation failed')
       }
     }
   }
@@ -630,14 +628,14 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     const signaturePolicy = this.globalSignaturePolicy
     switch (signaturePolicy) {
       case 'StrictSign':
-        return signMessage(this.components.peerId, message, this.encodeMessage.bind(this))
+        return signMessage(this.components.privateKey, message, this.encodeMessage.bind(this))
       case 'StrictNoSign':
         return Promise.resolve({
           type: 'unsigned',
           ...message
         })
       default:
-        throw new CodeError('Cannot build message: unhandled signature policy', codes.ERR_UNHANDLED_SIGNATURE_POLICY)
+        throw new InvalidMessageError('Cannot build message: unhandled signature policy')
     }
   }
 
@@ -648,11 +646,11 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
    */
   getSubscribers (topic: string): PeerId[] {
     if (!this.started) {
-      throw new CodeError('not started yet', 'ERR_NOT_STARTED_YET')
+      throw new NotStartedError('not started yet')
     }
 
     if (topic == null) {
-      throw new CodeError('topic is required', 'ERR_NOT_VALID_TOPIC')
+      throw new InvalidParametersError('Topic is required')
     }
 
     const peersInTopic = this.topics.get(topic.toString())

package/src/peer-streams.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { closeSource } from '@libp2p/utils/close-source'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'

package/src/sign.ts

@@ -1,31 +1,22 @@
-import { keys } from '@libp2p/crypto'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toRpcMessage } from './utils.js'
-import type { PeerId, PubSubRPCMessage, SignedMessage } from '@libp2p/interface'
+import type { PeerId, PrivateKey, PubSubRPCMessage, PublicKey, SignedMessage } from '@libp2p/interface'
 
 export const SignPrefix = uint8ArrayFromString('libp2p-pubsub:')
 
 /**
  * Signs the provided message with the given `peerId`
  */
-export async function signMessage (peerId: PeerId, message: { from: PeerId, topic: string, data: Uint8Array, sequenceNumber: bigint }, encode: (rpc: PubSubRPCMessage) => Uint8Array): Promise<SignedMessage> {
-  if (peerId.privateKey == null) {
-    throw new Error('Cannot sign message, no private key present')
-  }
-
-  if (peerId.publicKey == null) {
-    throw new Error('Cannot sign message, no public key present')
-  }
-
+export async function signMessage (privateKey: PrivateKey, message: { from: PeerId, topic: string, data: Uint8Array, sequenceNumber: bigint }, encode: (rpc: PubSubRPCMessage) => Uint8Array): Promise<SignedMessage> {
   // @ts-expect-error signature field is missing, added below
   const outputMessage: SignedMessage = {
     type: 'signed',
     topic: message.topic,
     data: message.data,
     sequenceNumber: message.sequenceNumber,
-    from: peerId
+    from: peerIdFromPrivateKey(privateKey)
   }
 
   // Get the message in bytes, and prepend with the pubsub prefix
@@ -34,9 +25,8 @@ export async function signMessage (peerId: PeerId, message: { from: PeerId, topi
     encode(toRpcMessage(outputMessage)).subarray()
   ])
 
-  const privateKey = await keys.unmarshalPrivateKey(peerId.privateKey)
   outputMessage.signature = await privateKey.sign(bytes)
-  outputMessage.key = peerId.publicKey
+  outputMessage.key = privateKey.publicKey
 
   return outputMessage
 }
@@ -68,8 +58,7 @@ export async function verifySignature (message: SignedMessage, encode: (rpc: Pub
   ])
 
   // Get the public key
-  const pubKeyBytes = await messagePublicKey(message)
-  const pubKey = keys.unmarshalPublicKey(pubKeyBytes)
+  const pubKey = messagePublicKey(message)
 
   // verify the base message
   return pubKey.verify(bytes, message.signature)
@@ -79,7 +68,7 @@ export async function verifySignature (message: SignedMessage, encode: (rpc: Pub
  * Returns the PublicKey associated with the given message.
  * If no valid PublicKey can be retrieved an error will be returned.
  */
-export async function messagePublicKey (message: SignedMessage): Promise<Uint8Array> {
+export function messagePublicKey (message: SignedMessage): PublicKey {
   if (message.type !== 'signed') {
     throw new Error('Message type must be "signed" to have a public key')
   }
@@ -90,11 +79,7 @@ export async function messagePublicKey (message: SignedMessage): Promise<Uint8Ar
   }
 
   if (message.key != null) {
-    const keyPeerId = await peerIdFromKeys(message.key)
-
-    if (keyPeerId.publicKey != null) {
-      return keyPeerId.publicKey
-    }
+    return message.key
   }
 
   if (message.from.publicKey != null) {

package/src/utils.ts

@@ -1,11 +1,12 @@
 import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface'
-import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
+import { InvalidMessageError } from '@libp2p/interface'
+import { peerIdFromMultihash, peerIdFromPublicKey } from '@libp2p/peer-id'
+import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { codes } from './errors.js'
-import type { Message, PubSubRPCMessage } from '@libp2p/interface'
+import type { Message, PubSubRPCMessage, PublicKey } from '@libp2p/interface'
 
 /**
  * Generate a random sequence number
@@ -17,12 +18,13 @@ export function randomSeqno (): bigint {
 /**
  * Generate a message id, based on the `key` and `seqno`
  */
-export const msgId = (key: Uint8Array, seqno: bigint): Uint8Array => {
+export const msgId = (key: PublicKey, seqno: bigint): Uint8Array => {
   const seqnoBytes = uint8ArrayFromString(seqno.toString(16).padStart(16, '0'), 'base16')
+  const keyBytes = publicKeyToProtobuf(key)
 
-  const msgId = new Uint8Array(key.length + seqnoBytes.length)
-  msgId.set(key, 0)
-  msgId.set(seqnoBytes, key.length)
+  const msgId = new Uint8Array(keyBytes.byteLength + seqnoBytes.length)
+  msgId.set(keyBytes, 0)
+  msgId.set(seqnoBytes, keyBytes.byteLength)
 
   return msgId
 }
@@ -71,13 +73,15 @@ const isSigned = async (message: PubSubRPCMessage): Promise<boolean> => {
     return false
   }
   // if a public key is present in the `from` field, the message should be signed
-  const fromID = peerIdFromBytes(message.from)
+  const fromID = peerIdFromMultihash(Digest.decode(message.from))
   if (fromID.publicKey != null) {
     return true
   }
 
   if (message.key != null) {
-    const signingID = await peerIdFromKeys(message.key)
+    const signingKey = message.key
+    const signingID = peerIdFromPublicKey(publicKeyFromProtobuf(signingKey))
+
     return signingID.equals(fromID)
   }
 
@@ -86,7 +90,7 @@ const isSigned = async (message: PubSubRPCMessage): Promise<boolean> => {
 
 export const toMessage = async (message: PubSubRPCMessage): Promise<Message> => {
   if (message.from == null) {
-    throw new CodeError('RPC message was missing from', codes.ERR_MISSING_FROM)
+    throw new InvalidMessageError('RPC message was missing from')
   }
 
   if (!await isSigned(message)) {
@@ -97,20 +101,21 @@ export const toMessage = async (message: PubSubRPCMessage): Promise<Message> =>
     }
   }
 
-  const from = peerIdFromBytes(message.from)
+  const from = peerIdFromMultihash(Digest.decode(message.from))
+  const key = message.key ?? from.publicKey
+
+  if (key == null) {
+    throw new InvalidMessageError('RPC message was missing public key')
+  }
 
   const msg: Message = {
     type: 'signed',
-    from: peerIdFromBytes(message.from),
+    from,
     topic: message.topic ?? '',
     sequenceNumber: bigIntFromBytes(message.sequenceNumber ?? new Uint8Array(0)),
     data: message.data ?? new Uint8Array(0),
     signature: message.signature ?? new Uint8Array(0),
-    key: message.key ?? from.publicKey ?? new Uint8Array(0)
-  }
-
-  if (msg.key.length === 0) {
-    throw new CodeError('Signed RPC message was missing key', codes.ERR_MISSING_KEY)
+    key: key instanceof Uint8Array ? publicKeyFromProtobuf(key) : key
   }
 
   return msg
@@ -119,12 +124,13 @@ export const toMessage = async (message: PubSubRPCMessage): Promise<Message> =>
 export const toRpcMessage = (message: Message): PubSubRPCMessage => {
   if (message.type === 'signed') {
     return {
-      from: message.from.multihash.bytes,
+      from: message.from.toMultihash().bytes,
       data: message.data,
       sequenceNumber: bigIntToBytes(message.sequenceNumber),
       topic: message.topic,
       signature: message.signature,
-      key: message.key
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      key: message.key ? publicKeyToProtobuf(message.key) : undefined
     }
   }
 

package/dist/src/errors.d.ts

@@ -1,51 +0,0 @@
-export declare const codes: {
-    /**
-     * Signature policy is invalid
-     */
-    ERR_INVALID_SIGNATURE_POLICY: string;
-    /**
-     * Signature policy is unhandled
-     */
-    ERR_UNHANDLED_SIGNATURE_POLICY: string;
-    /**
-     * Message expected to have a `signature`, but doesn't
-     */
-    ERR_MISSING_SIGNATURE: string;
-    /**
-     * Message expected to have a `seqno`, but doesn't
-     */
-    ERR_MISSING_SEQNO: string;
-    /**
-     * Message expected to have a `key`, but doesn't
-     */
-    ERR_MISSING_KEY: string;
-    /**
-     * Message `signature` is invalid
-     */
-    ERR_INVALID_SIGNATURE: string;
-    /**
-     * Message expected to have a `from`, but doesn't
-     */
-    ERR_MISSING_FROM: string;
-    /**
-     * Message expected to not have a `from`, but does
-     */
-    ERR_UNEXPECTED_FROM: string;
-    /**
-     * Message expected to not have a `signature`, but does
-     */
-    ERR_UNEXPECTED_SIGNATURE: string;
-    /**
-     * Message expected to not have a `key`, but does
-     */
-    ERR_UNEXPECTED_KEY: string;
-    /**
-     * Message expected to not have a `seqno`, but does
-     */
-    ERR_UNEXPECTED_SEQNO: string;
-    /**
-     * Message failed topic validator
-     */
-    ERR_TOPIC_VALIDATOR_REJECT: 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;IAChB;;OAEG;;IAEH;;OAEG;;IAKH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAKH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAGH;;OAEG;;CAEJ,CAAA"}

package/dist/src/errors.js

@@ -1,53 +0,0 @@
-export const codes = {
-    /**
-     * Signature policy is invalid
-     */
-    ERR_INVALID_SIGNATURE_POLICY: 'ERR_INVALID_SIGNATURE_POLICY',
-    /**
-     * Signature policy is unhandled
-     */
-    ERR_UNHANDLED_SIGNATURE_POLICY: 'ERR_UNHANDLED_SIGNATURE_POLICY',
-    // Strict signing codes
-    /**
-     * Message expected to have a `signature`, but doesn't
-     */
-    ERR_MISSING_SIGNATURE: 'ERR_MISSING_SIGNATURE',
-    /**
-     * Message expected to have a `seqno`, but doesn't
-     */
-    ERR_MISSING_SEQNO: 'ERR_MISSING_SEQNO',
-    /**
-     * Message expected to have a `key`, but doesn't
-     */
-    ERR_MISSING_KEY: 'ERR_MISSING_KEY',
-    /**
-     * Message `signature` is invalid
-     */
-    ERR_INVALID_SIGNATURE: 'ERR_INVALID_SIGNATURE',
-    /**
-     * Message expected to have a `from`, but doesn't
-     */
-    ERR_MISSING_FROM: 'ERR_MISSING_FROM',
-    // Strict no-signing codes
-    /**
-     * Message expected to not have a `from`, but does
-     */
-    ERR_UNEXPECTED_FROM: 'ERR_UNEXPECTED_FROM',
-    /**
-     * Message expected to not have a `signature`, but does
-     */
-    ERR_UNEXPECTED_SIGNATURE: 'ERR_UNEXPECTED_SIGNATURE',
-    /**
-     * Message expected to not have a `key`, but does
-     */
-    ERR_UNEXPECTED_KEY: 'ERR_UNEXPECTED_KEY',
-    /**
-     * Message expected to not have a `seqno`, but does
-     */
-    ERR_UNEXPECTED_SEQNO: 'ERR_UNEXPECTED_SEQNO',
-    /**
-     * Message failed topic validator
-     */
-    ERR_TOPIC_VALIDATOR_REJECT: 'ERR_TOPIC_VALIDATOR_REJECT'
-};
-//# 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;;OAEG;IACH,4BAA4B,EAAE,8BAA8B;IAC5D;;OAEG;IACH,8BAA8B,EAAE,gCAAgC;IAEhE,uBAAuB;IAEvB;;OAEG;IACH,qBAAqB,EAAE,uBAAuB;IAC9C;;OAEG;IACH,iBAAiB,EAAE,mBAAmB;IACtC;;OAEG;IACH,eAAe,EAAE,iBAAiB;IAClC;;OAEG;IACH,qBAAqB,EAAE,uBAAuB;IAC9C;;OAEG;IACH,gBAAgB,EAAE,kBAAkB;IAEpC,0BAA0B;IAE1B;;OAEG;IACH,mBAAmB,EAAE,qBAAqB;IAC1C;;OAEG;IACH,wBAAwB,EAAE,0BAA0B;IACpD;;OAEG;IACH,kBAAkB,EAAE,oBAAoB;IACxC;;OAEG;IACH,oBAAoB,EAAE,sBAAsB;IAE5C;;OAEG;IACH,0BAA0B,EAAE,4BAA4B;CACzD,CAAA"}

package/src/errors.ts

@@ -1,57 +0,0 @@
-export const codes = {
-  /**
-   * Signature policy is invalid
-   */
-  ERR_INVALID_SIGNATURE_POLICY: 'ERR_INVALID_SIGNATURE_POLICY',
-  /**
-   * Signature policy is unhandled
-   */
-  ERR_UNHANDLED_SIGNATURE_POLICY: 'ERR_UNHANDLED_SIGNATURE_POLICY',
-
-  // Strict signing codes
-
-  /**
-   * Message expected to have a `signature`, but doesn't
-   */
-  ERR_MISSING_SIGNATURE: 'ERR_MISSING_SIGNATURE',
-  /**
-   * Message expected to have a `seqno`, but doesn't
-   */
-  ERR_MISSING_SEQNO: 'ERR_MISSING_SEQNO',
-  /**
-   * Message expected to have a `key`, but doesn't
-   */
-  ERR_MISSING_KEY: 'ERR_MISSING_KEY',
-  /**
-   * Message `signature` is invalid
-   */
-  ERR_INVALID_SIGNATURE: 'ERR_INVALID_SIGNATURE',
-  /**
-   * Message expected to have a `from`, but doesn't
-   */
-  ERR_MISSING_FROM: 'ERR_MISSING_FROM',
-
-  // Strict no-signing codes
-
-  /**
-   * Message expected to not have a `from`, but does
-   */
-  ERR_UNEXPECTED_FROM: 'ERR_UNEXPECTED_FROM',
-  /**
-   * Message expected to not have a `signature`, but does
-   */
-  ERR_UNEXPECTED_SIGNATURE: 'ERR_UNEXPECTED_SIGNATURE',
-  /**
-   * Message expected to not have a `key`, but does
-   */
-  ERR_UNEXPECTED_KEY: 'ERR_UNEXPECTED_KEY',
-  /**
-   * Message expected to not have a `seqno`, but does
-   */
-  ERR_UNEXPECTED_SEQNO: 'ERR_UNEXPECTED_SEQNO',
-
-  /**
-   * Message failed topic validator
-   */
-  ERR_TOPIC_VALIDATOR_REJECT: 'ERR_TOPIC_VALIDATOR_REJECT'
-}