@libp2p/pubsub 1.2.3 → 1.2.7

package/src/message/rpc.proto

@@ -2,19 +2,53 @@ syntax = "proto3";
 
 message RPC {
   repeated SubOpts subscriptions = 1;
-  repeated Message msgs = 2;
+  repeated Message messages = 2;
+  optional ControlMessage control = 3;
 
   message SubOpts {
     optional bool subscribe = 1; // subscribe or unsubcribe
-    optional string topicID = 2;
+    optional string topic = 2;
   }
 
   message Message {
     optional bytes from = 1;
     optional bytes data = 2;
     optional bytes seqno = 3;
-    repeated string topicIDs = 4;
+    optional string topic = 4;
     optional bytes signature = 5;
     optional bytes key = 6;
   }
-}
+}
+
+message ControlMessage {
+  repeated ControlIHave ihave = 1;
+  repeated ControlIWant iwant = 2;
+  repeated ControlGraft graft = 3;
+  repeated ControlPrune prune = 4;
+}
+
+message ControlIHave {
+  optional string topicID = 1;
+  // implementors from other languages should use bytes here - go protobuf emits invalid utf8 strings
+  repeated string messageIDs = 2;
+}
+
+message ControlIWant {
+  // implementors from other languages should use bytes here - go protobuf emits invalid utf8 strings
+  repeated string messageIDs = 1;
+}
+
+message ControlGraft {
+  optional string topicID = 1;
+}
+
+message ControlPrune {
+  optional string topicID = 1;
+  repeated PeerInfo peers = 2;
+  optional uint64 backoff = 3;
+}
+
+message PeerInfo {
+  optional bytes peerID = 1;
+  optional bytes signedPeerRecord = 2;
+}

package/src/message/sign.ts

@@ -1,12 +1,11 @@
-import * as PeerIdFactory from '@libp2p/peer-id-factory'
 import { RPC } from './rpc.js'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { normalizeOutRpcMessage } from '../utils.js'
+import { toRpcMessage } from '../utils.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { keys } from '@libp2p/crypto'
-import { PeerId as PeerIdImpl } from '@libp2p/peer-id'
 import type { Message } from '@libp2p/interfaces/pubsub'
+import { peerIdFromKeys } from '@libp2p/peer-id'
 
 export const SignPrefix = uint8ArrayFromString('libp2p-pubsub:')
 
@@ -17,7 +16,7 @@ export async function signMessage (peerId: PeerId, message: Message) {
   // Get the message in bytes, and prepend with the pubsub prefix
   const bytes = uint8ArrayConcat([
     SignPrefix,
-    RPC.Message.encode(normalizeOutRpcMessage(message)).finish()
+    RPC.Message.encode(toRpcMessage(message)).finish()
   ])
 
   if (peerId.privateKey == null) {
@@ -56,7 +55,7 @@ export async function verifySignature (message: Message) {
   const bytes = uint8ArrayConcat([
     SignPrefix,
     RPC.Message.encode({
-      ...message,
+      ...toRpcMessage(message),
       signature: undefined,
       key: undefined
     }).finish()
@@ -72,7 +71,7 @@ export async function verifySignature (message: Message) {
 
 /**
  * Returns the PublicKey associated with the given message.
- * If no, valid PublicKey can be retrieved an error will be returned.
+ * If no valid PublicKey can be retrieved an error will be returned.
  */
 export async function messagePublicKey (message: Message) {
   // should be available in the from property of the message (peer id)
@@ -80,21 +79,16 @@ export async function messagePublicKey (message: Message) {
     throw new Error('Could not get the public key from the originator id')
   }
 
-  const from = PeerIdImpl.fromBytes(message.from)
-
   if (message.key != null) {
-    const keyPeerId = await PeerIdFactory.createFromPubKey(keys.unmarshalPublicKey(message.key))
-
-    // the key belongs to the sender, return the key
-    if (!keyPeerId.equals(from)) {
-      throw new Error('Public Key does not match the originator')
-    }
+    const keyPeerId = await peerIdFromKeys(message.key)
 
     if (keyPeerId.publicKey != null) {
       return keyPeerId.publicKey
     }
-  } else if (from.publicKey != null) {
-    return from.publicKey
+  }
+
+  if (message.from.publicKey != null) {
+    return message.from.publicKey
   }
 
   // We couldn't validate pubkey is from the originator, error

package/src/peer-streams.ts

@@ -25,19 +25,19 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
   /**
    * Write stream - it's preferable to use the write method
    */
-  public outboundStream: Pushable<Uint8Array> | undefined
+  public outboundStream?: Pushable<Uint8Array>
   /**
    * Read stream
    */
-  public inboundStream: AsyncIterable<Uint8Array> | undefined
+  public inboundStream?: AsyncIterable<Uint8Array>
   /**
    * The raw outbound stream, as retrieved from conn.newStream
    */
-  private _rawOutboundStream: Stream | undefined
+  private _rawOutboundStream?: Stream
   /**
    * The raw inbound stream, as retrieved from the callback from libp2p.handle
    */
-  private _rawInboundStream: Stream | undefined
+  private _rawInboundStream?: Stream
   /**
    * An AbortController for controlled shutdown of the inbound stream
    */
@@ -142,6 +142,8 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
     if (_prevStream == null) {
       this.dispatchEvent(new CustomEvent('stream:outbound'))
     }
+
+    return this.outboundStream
   }
 
   /**

package/src/utils.ts

@@ -1,39 +1,39 @@
 import { randomBytes } from 'iso-random-stream'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { PeerId } from '@libp2p/peer-id'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { sha256 } from 'multiformats/hashes/sha2'
 import type * as RPC from './message/rpc.js'
-import type { Message } from '@libp2p/interfaces/pubsub'
+import type { Message, RPCMessage } from '@libp2p/interfaces/pubsub'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { codes } from './errors.js'
+import errcode from 'err-code'
 
 /**
  * Generate a random sequence number
  */
-export const randomSeqno = () => {
-  return randomBytes(8)
+export function randomSeqno (): BigInt {
+  return BigInt(`0x${uint8ArrayToString(randomBytes(8), 'base16')}`)
 }
 
 /**
- * Generate a message id, based on the `from` and `seqno`
+ * Generate a message id, based on the `key` and `seqno`
  */
-export const msgId = (from: Uint8Array | string, seqno: Uint8Array) => {
-  let fromBytes
+export const msgId = (key: Uint8Array, seqno: BigInt) => {
+  const seqnoBytes = uint8ArrayFromString(seqno.toString(16).padStart(16, '0'), 'base16')
 
-  if (from instanceof Uint8Array) {
-    fromBytes = PeerId.fromBytes(from).multihash.digest
-  } else {
-    fromBytes = PeerId.fromString(from).multihash.digest
-  }
+  const msgId = new Uint8Array(key.length + seqnoBytes.length)
+  msgId.set(key, 0)
+  msgId.set(seqnoBytes, key.length)
 
-  const msgId = new Uint8Array(fromBytes.length + seqno.length)
-  msgId.set(fromBytes, 0)
-  msgId.set(seqno, fromBytes.length)
   return msgId
 }
 
 /**
  * Generate a message id, based on message `data`
  */
-export const noSignMsgId = (data: Uint8Array) => sha256.encode(data)
+export const noSignMsgId = (data: Uint8Array) => {
+  return sha256.encode(data)
+}
 
 /**
  * Check if any member of the first set is also a member
@@ -67,27 +67,28 @@ export const ensureArray = function <T> (maybeArray: T | T[]) {
   return maybeArray
 }
 
-/**
- * Ensures `message.from` is base58 encoded
- */
-export const normalizeInRpcMessage = (message: RPC.RPC.IMessage, peerId?: string) => {
-  // @ts-expect-error receivedFrom not yet defined
-  const m: NormalizedIMessage = Object.assign({}, message)
-
-  if (peerId != null) {
-    m.receivedFrom = peerId
+export const toMessage = (message: RPC.RPC.IMessage): Message => {
+  if (message.from == null) {
+    throw errcode(new Error('RPC message was missing from'), codes.ERR_MISSING_FROM)
   }
 
-  return m
+  return {
+    from: peerIdFromBytes(message.from),
+    topic: message.topic ?? '',
+    seqno: message.seqno == null ? undefined : BigInt(`0x${uint8ArrayToString(message.seqno, 'base16')}`),
+    data: message.data ?? new Uint8Array(0),
+    signature: message.signature ?? undefined,
+    key: message.key ?? undefined
+  }
 }
 
-export const normalizeOutRpcMessage = (message: Message) => {
-  const m: Message = Object.assign({}, message)
-  if (typeof message.from === 'string') {
-    m.from = uint8ArrayFromString(message.from, 'base58btc')
-  }
-  if (typeof message.data === 'string') {
-    m.data = uint8ArrayFromString(message.data)
+export const toRpcMessage = (message: Message): RPCMessage => {
+  return {
+    from: message.from.multihash.bytes,
+    data: message.data,
+    seqno: message.seqno == null ? undefined : uint8ArrayFromString(message.seqno.toString(16).padStart(16, '0'), 'base16'),
+    topic: message.topic,
+    signature: message.signature,
+    key: message.key
   }
-  return m
 }