@libp2p/pubsub 1.2.6 → 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,4 +1,3 @@
-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'
@@ -6,6 +5,7 @@ import { toRpcMessage } from '../utils.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { keys } from '@libp2p/crypto'
 import type { Message } from '@libp2p/interfaces/pubsub'
+import { peerIdFromKeys } from '@libp2p/peer-id'
 
 export const SignPrefix = uint8ArrayFromString('libp2p-pubsub:')
 
@@ -71,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,17 +80,14 @@ export async function messagePublicKey (message: Message) {
   }
 
   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(message.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 (message.from.publicKey != null) {
+  }
+
+  if (message.from.publicKey != null) {
     return message.from.publicKey
   }
 

package/src/utils.ts

@@ -1,13 +1,12 @@
 import { randomBytes } from 'iso-random-stream'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { peerIdFromBytes } from '@libp2p/peer-id'
 import { sha256 } from 'multiformats/hashes/sha2'
-import errcode from 'err-code'
-import { codes } from './errors.js'
 import type * as RPC from './message/rpc.js'
 import type { Message, RPCMessage } from '@libp2p/interfaces/pubsub'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { codes } from './errors.js'
+import errcode from 'err-code'
 
 /**
  * Generate a random sequence number
@@ -17,15 +16,14 @@ export function randomSeqno (): BigInt {
 }
 
 /**
- * Generate a message id, based on the `from` and `seqno`
+ * Generate a message id, based on the `key` and `seqno`
  */
-export const msgId = (from: PeerId, seqno: BigInt) => {
-  const fromBytes = from.multihash.digest
+export const msgId = (key: Uint8Array, seqno: BigInt) => {
   const seqnoBytes = uint8ArrayFromString(seqno.toString(16).padStart(16, '0'), 'base16')
 
-  const msgId = new Uint8Array(fromBytes.length + seqnoBytes.length)
-  msgId.set(fromBytes, 0)
-  msgId.set(seqnoBytes, fromBytes.length)
+  const msgId = new Uint8Array(key.length + seqnoBytes.length)
+  msgId.set(key, 0)
+  msgId.set(seqnoBytes, key.length)
 
   return msgId
 }
@@ -69,17 +67,14 @@ export const ensureArray = function <T> (maybeArray: T | T[]) {
   return maybeArray
 }
 
-/**
- * Ensures `message.from` is base58 encoded
- */
 export const toMessage = (message: RPC.RPC.IMessage): Message => {
   if (message.from == null) {
-    throw errcode(new Error('From field is required and was not present'), codes.ERR_MISSING_FROM)
+    throw errcode(new Error('RPC message was missing from'), codes.ERR_MISSING_FROM)
   }
 
   return {
     from: peerIdFromBytes(message.from),
-    topicIDs: message.topicIDs ?? [],
+    topic: message.topic ?? '',
     seqno: message.seqno == null ? undefined : BigInt(`0x${uint8ArrayToString(message.seqno, 'base16')}`),
     data: message.data ?? new Uint8Array(0),
     signature: message.signature ?? undefined,
@@ -88,15 +83,11 @@ export const toMessage = (message: RPC.RPC.IMessage): Message => {
 }
 
 export const toRpcMessage = (message: Message): RPCMessage => {
-  if (message.from == null) {
-    throw errcode(new Error('From field is required and was not present'), codes.ERR_MISSING_FROM)
-  }
-
   return {
     from: message.from.multihash.bytes,
     data: message.data,
     seqno: message.seqno == null ? undefined : uint8ArrayFromString(message.seqno.toString(16).padStart(16, '0'), 'base16'),
-    topicIDs: message.topicIDs,
+    topic: message.topic,
     signature: message.signature,
     key: message.key
   }