updated config keypair to pchain type

src/behaviour.rs

@@ -194,7 +194,7 @@ mod test {
         identity::{ed25519, PeerId},
         Multiaddr,
     };
-    use pchain_types::cryptography::PublicAddress;
+    use pchain_types::cryptography::{PublicAddress, self};
 
     use crate::{
         config::Config,
@@ -212,8 +212,10 @@ mod test {
     }
 
     fn create_new_peer() -> Peer {
+        let keypair = ed25519::Keypair::generate();
+        let local_keypair = cryptography::Keypair::from_keypair_bytes(&keypair.to_bytes()).unwrap();
         let config = Config {
-            keypair: ed25519::Keypair::generate(),
+            keypair: local_keypair,
             topics_to_subscribe: vec![Topic::HotStuffRsBroadcast],
             listening_port: 25519,
             boot_nodes: vec![],
@@ -222,11 +224,11 @@ mod test {
             kademlia_protocol_name: String::from("/test"),
         };
 
-        let public_address = config.keypair.public().to_bytes();
+        let public_address = config.keypair.verifying_key().to_bytes();
 
         let behaviour = Behaviour::new(
             public_address,
-            &config.keypair,
+            &keypair,
             config.kademlia_protocol_name,
         );
 

src/config.rs

@@ -9,7 +9,7 @@
 //!
 //! ```no_run
 //!     let config = Config {
-//!         keypair: libp2p_identity::ed25519::Keypair::generate(),
+//!         keypair: pchain_types::cryptography::Keypair,
 //!         topics_to_subscribe: vec![Topic::HotStuffRsBroadcast],
 //!         listening_port: 25519,
 //!         boot_nodes: vec![],
@@ -20,8 +20,7 @@
 //! ```
 //!
 use std::net::Ipv4Addr;
-use libp2p::identity::ed25519::Keypair;
-use pchain_types::cryptography::PublicAddress;
+use pchain_types::cryptography::{Keypair, PublicAddress};
 
 use crate::messages::Topic;
 

src/lib.rs

@@ -16,7 +16,7 @@
 //!
 //! // 1. Build a configuration.
 //! let config = Config {
-//!     keypair, // libp2p_identity::ed25519::Keypair::generate()
+//!     keypair, // pchain_types::cryptography::Keypair
 //!     topics_to_subscribe, // vec![Topic::HotStuffRsBroadcast]
 //!     listening_port, // 25519
 //!     boot_nodes, // vec![]
@@ -27,13 +27,18 @@
 //!
 //! // 2. Create message handlers 
 //! let (tx, rx) = mpsc::channel();
-//! let message_sender = tx.clone();
-//! let message_handler = move |msg_orgin: [u8;32], msg: Message| {
-//!     // processing the message...
-//!     let _ = message_sender.send((msg_origin, msg));
+//! let hotstuff_sender = tx.clone();
+//! let hotstuff_handler = move |msg_orgin: [u8;32], msg: Message| {
+//!     match msg {
+//!         Message::HotStuffRs(hotstuff_message) => {
+//!             //process hotstuff message
+//!             let _ = hotstuff_sender.send((msg_origin, Message::HotStuffRs(hotstuff_message)));
+//!         }
+//!         _ => {}
+//!     }  
 //! };
 //! let mut message_handlers: Vec<Box<dyn Fn(PublicAddress, Message) + Send>> = vec![];
-//! message_handlers.push(Box::new(message_handler));
+//! message_handlers.push(Box::new(hotstuff_handler));
 //!  
 //! // 3. Start P2P network.
 //! let peer = Peer::start(config, message_handlers)
@@ -49,6 +54,7 @@
 pub mod behaviour;
 
 pub mod config;
+pub use config::Config;
 
 pub mod conversions;
 

src/peer.rs

@@ -40,7 +40,7 @@ use libp2p::{
     core::{muxing::StreamMuxerBox, transport::Boxed},
     dns::TokioDnsConfig,
     gossipsub,
-    identify, identity::{self}, noise,
+    identify, identity::{self, ed25519::Keypair}, noise,
     swarm::{SwarmBuilder, SwarmEvent},
     tcp, yamux, PeerId, Transport,
 };
@@ -141,18 +141,19 @@ pub(crate) enum PeerCommand {
 async fn set_up_transport(config: &Config) -> Result<libp2p::Swarm<Behaviour>,std::io::Error> {
     // Read network configuration 
     let local_keypair = &config.keypair;
-    let local_public_address: PublicAddress = local_keypair.public().to_bytes();
-    let local_peer_id = identity::Keypair::from(local_keypair.clone())
+    let local_public_address: PublicAddress = local_keypair.verifying_key().to_bytes();
+    let local_libp2p_keypair = Keypair::try_from_bytes(config.keypair.to_keypair_bytes().as_mut_slice()).unwrap();
+    let local_peer_id = identity::Keypair::from(local_libp2p_keypair.clone())
         .public()
         .to_peer_id();
 
     log::info!("Local PeerId: {:?}", local_peer_id);
 
     // Instantiate Swarm
-    let transport = build_transport(local_keypair.clone()).await?;
+    let transport = build_transport(local_libp2p_keypair.clone()).await?;
     let behaviour = Behaviour::new(
         local_public_address,
-        &local_keypair,
+        &local_libp2p_keypair,
         config.kademlia_protocol_name.clone(),
     );
     let swarm = SwarmBuilder::with_tokio_executor(transport, behaviour, local_peer_id).build();
@@ -211,10 +212,13 @@ fn establish_network_connections(mut swarm: libp2p::Swarm<Behaviour> , config: &
 fn start_event_handling(mut swarm: libp2p::Swarm<Behaviour>, config: &Config, message_handlers: Vec<Box<dyn Fn(PublicAddress, Message) + Send>>) -> 
     (JoinHandle<()>,tokio::sync::mpsc::Sender<PeerCommand>) {
     // 4. Start p2p networking
-    let local_public_address = config.keypair.public().to_bytes();
-    let local_peer_id = identity::Keypair::from(config.keypair.clone())
+    let local_keypair = &config.keypair;
+    let local_public_address: PublicAddress = local_keypair.verifying_key().to_bytes();
+    let local_libp2p_keypair = Keypair::try_from_bytes(config.keypair.to_keypair_bytes().as_mut_slice()).unwrap();
+    let local_peer_id = identity::Keypair::from(local_libp2p_keypair.clone())
         .public()
         .to_peer_id();
+
     let (sender, mut receiver) =
         tokio::sync::mpsc::channel::<PeerCommand>(config.outgoing_msgs_buffer_capacity);
     let mut discover_tick =

tests/network.rs

@@ -8,6 +8,7 @@ use pchain_network::{
     config::Config,
     messages::{Topic, Message},
 };
+use pchain_types::cryptography;
 use pchain_types::{blockchain::TransactionV1, cryptography::PublicAddress};
 
 fn base_tx(signer: PublicAddress) -> TransactionV1 {
@@ -470,9 +471,9 @@ pub async fn node(
     boot_nodes: Vec<([u8;32], Ipv4Addr, u16)>,
     topics_to_subscribe: Vec<Topic>
 ) -> (Peer, std::sync::mpsc::Receiver<(PublicAddress, Message)>) {
-
+    let local_keypair = cryptography::Keypair::from_keypair_bytes(&keypair.to_bytes()).unwrap();
     let config = Config {
-        keypair,
+        keypair: local_keypair,
         topics_to_subscribe,
         listening_port,
         boot_nodes,