slight naming fixes [skip ci]

Author: erhant

compute/src/config.rs

@@ -4,7 +4,7 @@ use eyre::{eyre, Result};
 use libsecp256k1::{PublicKey, SecretKey};
 use std::{env, str::FromStr};
 
-use crate::utils::crypto::{secret_to_keypair, to_address};
+use crate::utils::crypto::{public_key_to_address, secret_to_keypair};
 
 const DEFAULT_TASK_BATCH_SIZE: usize = 5;
 const DEFAULT_P2P_LISTEN_ADDR: &str = "/ip4/0.0.0.0/tcp/4001";
@@ -64,7 +64,7 @@ impl DriaComputeNodeConfig {
             hex::encode(public_key.serialize_compressed())
         );
 
-        let address = to_address(&public_key);
+        let address = public_key_to_address(&public_key);
         log::info!("Node Address:     0x{}", hex::encode(address));
 
         // to this here to log the peer id at start

compute/src/node/gossipsub.rs

@@ -1,4 +1,4 @@
-use dkn_p2p::libp2p::gossipsub::{Message, MessageAcceptance, MessageId};
+use dkn_p2p::libp2p::gossipsub::{Message, MessageAcceptance, MessageId, TopicSubscriptionFilter};
 use dkn_p2p::libp2p::PeerId;
 use eyre::Result;
 
@@ -53,7 +53,7 @@ impl DriaComputeNode {
     /// Handles a GossipSub message received from the network.
     pub(crate) async fn handle_message(
         &mut self,
-        (peer_id, message_id, gossipsub_message): (PeerId, &MessageId, Message),
+        (propagation_peer_id, message_id, gossipsub_message): (PeerId, &MessageId, Message),
     ) -> MessageAcceptance {
         // handle message with respect to its topic
         match gossipsub_message.topic.as_str() {
@@ -63,7 +63,7 @@ impl DriaComputeNode {
                     log::warn!(
                         "Received {} message from {} without source.",
                         gossipsub_message.topic,
-                        peer_id
+                        propagation_peer_id
                     );
                     return MessageAcceptance::Ignore;
                 };
@@ -98,7 +98,7 @@ impl DriaComputeNode {
                     "Received {} message ({}) from {}\n{}",
                     gossipsub_message.topic,
                     message_id,
-                    peer_id,
+                    propagation_peer_id,
                     message
                 );
 

compute/src/utils/crypto.rs

@@ -1,6 +1,4 @@
 use dkn_p2p::{libp2p::PeerId, libp2p_identity};
-use ecies::PublicKey;
-use libsecp256k1::SecretKey;
 use sha2::{Digest, Sha256};
 use sha3::Keccak256;
 
@@ -16,33 +14,33 @@ pub fn keccak256hash(data: impl AsRef<[u8]>) -> [u8; 32] {
     Keccak256::digest(data).into()
 }
 
+/// Converts a `libsecp256k1::SecretKey` to a `libp2p_identity::secp256k1::Keypair`.
+/// To do this, we serialize the secret key and create a new keypair from it.
+#[inline]
+pub fn secret_to_keypair(secret_key: &libsecp256k1::SecretKey) -> libp2p_identity::Keypair {
+    let bytes = secret_key.serialize();
+
+    let secret_key = dkn_p2p::libp2p_identity::secp256k1::SecretKey::try_from_bytes(bytes)
+        .expect("Failed to create secret key");
+    libp2p_identity::secp256k1::Keypair::from(secret_key).into()
+}
+
 /// Given a secp256k1 public key, finds the corresponding Ethereum address.
 ///
 /// Internally, the public key is serialized in uncompressed format at 65 bytes (0x04 || x || y),
 /// and then (x || y) is hashed using Keccak256. The last 20 bytes of this hash is taken as the address.
 #[inline]
-pub fn to_address(public_key: &PublicKey) -> [u8; 20] {
+pub fn public_key_to_address(public_key: &libsecp256k1::PublicKey) -> [u8; 20] {
     let public_key_xy = &public_key.serialize()[1..];
     let mut addr = [0u8; 20];
     addr.copy_from_slice(&keccak256hash(public_key_xy)[12..32]);
     addr
 }
 
-/// Converts a `libsecp256k1::SecretKey` to a `libp2p_identity::secp256k1::Keypair`.
-/// To do this, we serialize the secret key and create a new keypair from it.
-#[inline]
-pub fn secret_to_keypair(secret_key: &SecretKey) -> libp2p_identity::Keypair {
-    let bytes = secret_key.serialize();
-
-    let secret_key = dkn_p2p::libp2p_identity::secp256k1::SecretKey::try_from_bytes(bytes)
-        .expect("Failed to create secret key");
-    libp2p_identity::secp256k1::Keypair::from(secret_key).into()
-}
-
 /// Converts a `libsecp256k1::PublicKey` to a `libp2p_identity::PeerId`.
 /// To do this, we serialize the secret key and create a new keypair from it.
 #[inline]
-pub fn public_key_to_peer_id(public_key: &PublicKey) -> libp2p_identity::PeerId {
+pub fn public_key_to_peer_id(public_key: &libsecp256k1::PublicKey) -> libp2p_identity::PeerId {
     let bytes = public_key.serialize_compressed();
 
     let public_key = dkn_p2p::libp2p_identity::secp256k1::PublicKey::try_from_bytes(&bytes)
@@ -73,7 +71,7 @@ mod tests {
     fn test_address() {
         let sk = SecretKey::parse_slice(DUMMY_SECRET_KEY).expect("Should parse key.");
         let pk = PublicKey::from_secret_key(&sk);
-        let addr = to_address(&pk);
+        let addr = public_key_to_address(&pk);
         assert_eq!(
             "D79Fdf178547614CFdd0dF6397c53569716Bd596".to_lowercase(),
             hex::encode(addr)

compute/src/utils/message.rs

@@ -78,6 +78,14 @@ impl DriaMessage {
 
     /// Checks if the payload is signed by the owner of one of the given peer ids.
     pub(crate) fn is_signed(&self, authorized_peerids: &HashSet<PeerId>) -> Result<bool> {
+        let recovered_public_key = self.get_origin()?;
+        let recovered_peer_id = public_key_to_peer_id(&recovered_public_key);
+
+        Ok(authorized_peerids.contains(&recovered_peer_id))
+    }
+
+    /// Recovers the public key of the message origin, i.e. the owner of the signature.
+    pub(crate) fn get_origin(&self) -> Result<libsecp256k1::PublicKey> {
         let signature_bytes =
             hex::decode(&self.signature).wrap_err("could not decode signature hex")?;
         let signature = Signature::parse_standard_slice(&signature_bytes)
@@ -89,10 +97,7 @@ impl DriaMessage {
         // verify signature w.r.t the payload and the given public key
         let message = Message::parse(&sha256hash(&self.payload));
 
-        let recovered_public_key = recover(&message, &signature, &recovery_id)?;
-        let recovered_peer_id = public_key_to_peer_id(&recovered_public_key);
-
-        Ok(authorized_peerids.contains(&recovered_peer_id))
+        recover(&message, &signature, &recovery_id).wrap_err("could not recover public key")
     }
 
     /// Converts the message to bytes.