wip: to soft: elois resolve conflicts with dev

lib/modules/ws2p/ws2p-messages/v2/connect.rs

@@ -69,7 +69,7 @@ impl Default for WS2Pv2ConnectMsg {
     fn default() -> Self {
         WS2Pv2ConnectMsg {
             challenge: Hash::random(),
-            api_features: WS2PFeatures(vec![]),
+            api_features: WS2PFeatures([0u8; 4]),
             connect_type: WS2Pv2ConnectType::OutgoingServer,
             peer_card: None,
             chunkstamp: None,
@@ -118,7 +118,7 @@ mod tests {
                 "000007722B243094269E548F600BD34D73449F7578C05BD370A6D301D20B5F10",
             )
             .unwrap(),
-            api_features: WS2PFeatures(vec![7u8]),
+            api_features: WS2PFeatures([7u8, 0, 0, 0]),
             connect_type: WS2Pv2ConnectType::OutgoingClient,
             peer_card: Some(peer),
             chunkstamp: Some(

lib/modules/ws2p/ws2p-messages/v2/ok.rs

@@ -33,7 +33,6 @@ mod tests {
     use super::super::*;
     use super::*;
     use crate::tests::*;
-    use dubp_common_doc::Blockstamp;
     use std::num::NonZeroU16;
 
     #[test]

lib/modules/ws2p/ws2p-protocol/src/orchestrator.rs

@@ -35,6 +35,7 @@ use crate::MySelfWs2pNode;
 use dubp_common_doc::BlockHash;
 use dubp_common_doc::Blockstamp;
 use dubp_common_doc::CurrencyName;
+use dup_crypto::keys::{KeyPair, SignatorEnum};
 use durs_common_tools::fatal_error;
 use durs_message::DursMsg;
 use durs_module::ModuleMessage;
@@ -83,6 +84,8 @@ pub struct WS2POrchestrator {
     router_sender: mpsc::Sender<RouterThreadMessage<DursMsg>>,
     /// the channel used to send message to orchestrator itself
     pub sender: mpsc::Sender<OrchestratorMsg<DursMsg>>,
+    /// Self signator
+    self_signator: SignatorEnum,
     /// the channel used to receive message
     receiver: mpsc::Receiver<OrchestratorMsg<DursMsg>>,
     /// channel used to give orders to outgoing orchestrator
@@ -99,6 +102,7 @@ impl WS2POrchestrator {
         module_receiver: mpsc::Receiver<DursMsg>,
         api_name: ApiName,
         self_node: MySelfWs2pNode,
+        self_signator: SignatorEnum,
     ) -> (WS2POutgoingOrchestrator<WS>, WS2POrchestrator) {
         // starts proxy thread
         let (orchestrator_sender, orchestrator_receiver) = start_proxy_thread(
@@ -109,12 +113,19 @@ impl WS2POrchestrator {
             api_name,
         );
 
+        // Regenerate self_signator for main orchestrator
+        let self_signator_2 = self_node
+            .my_key_pair
+            .generate_signator()
+            .expect("corrupted keypair"); // TODO handle error
+
         // OUTGOING: initialize the outgoing orchestrator
         let outgoing_orchestrator = WS2POutgoingOrchestrator::<WS>::new(
             static_name,
             // how to find currency before sync ?
             CurrencyName("mok".to_string()),
             self_node,
+            self_signator,
             router_sender.clone(),
             orchestrator_sender.clone(),
         );
@@ -127,6 +138,7 @@ impl WS2POrchestrator {
             peers: HashMap::new(),
             router_sender,
             sender: orchestrator_sender,
+            self_signator: self_signator_2,
             receiver: orchestrator_receiver,
             outgoing_sender: outgoing_orchestrator.sender.clone(),
         };

lib/modules/ws2p/ws2p-protocol/src/orchestrator/outgoing.rs

@@ -26,6 +26,7 @@ use crate::MySelfWs2pNode;
 use core::fmt::Debug;
 use dubp_common_doc::Blockstamp;
 use dubp_common_doc::CurrencyName;
+use dup_crypto::keys::SignatorEnum;
 use durs_common_tools::fatal_error;
 use durs_message::requests::*;
 use durs_message::*;
@@ -94,6 +95,8 @@ pub struct WS2POutgoingOrchestrator<WS: WebsocketTrait> {
     currency: CurrencyName,
     /// Local node datas
     self_node: MySelfWs2pNode,
+    /// Self signator
+    self_signator: SignatorEnum,
     /// Outgoing connections quota
     quota: usize,
     /// Index hashmap linking NodeFullId to WS2PControllerId
@@ -123,6 +126,7 @@ impl<WS: WebsocketTrait> WS2POutgoingOrchestrator<WS> {
         static_name: ModuleStaticName,
         currency: CurrencyName,
         self_node: MySelfWs2pNode,
+        self_signator: SignatorEnum,
         router_sender: mpsc::Sender<RouterThreadMessage<DursMsg>>,
         orchestrator_sender: mpsc::Sender<OrchestratorMsg<DursMsg>>,
     ) -> WS2POutgoingOrchestrator<WS> {
@@ -147,6 +151,7 @@ impl<WS: WebsocketTrait> WS2POutgoingOrchestrator<WS> {
             endpoints_in_error: HashMap::new(),
             never_try_endpoints: Vec::new(),
             self_node,
+            self_signator,
             router_sender,
             sender,
             receiver,
@@ -248,7 +253,7 @@ impl<WS: WebsocketTrait> WS2POutgoingOrchestrator<WS> {
                                 WS2Pv2Message::encapsulate_payload(
                                     self.currency.clone(),
                                     self.self_node.my_node_id,
-                                    self.self_node.my_key_pair,
+                                    &self.self_signator,
                                     WS2Pv2MessagePayload::SyncInfo(sync_info),
                                 )
                             {

lib/modules/ws2p/ws2p/src/lib.rs

@@ -44,7 +44,7 @@ use crate::errors::WS2PError;
 use crate::websocket::WebsocketConnector;
 use dubp_common_doc::BlockNumber;
 use dubp_currency_params::CurrencyName;
-use dup_crypto::keys::KeyPairEnum;
+use dup_crypto::keys::{KeyPair, KeyPairEnum};
 use durs_common_tools::fatal_error;
 use durs_common_tools::traits::merge::Merge;
 use durs_conf::DuRsConf;
@@ -276,10 +276,13 @@ fn init(
     // generate node id
     let node_id = NodeId(rand::thread_rng().gen::<u32>());
 
+    // generate self signator
+    let self_signator = key_pair.generate_signator().expect("corrupted keypair"); // TODO handle error
+
     // generate peer card
     let peer_card = if let Ok(peer_card) = generate_peer::_generate_self_peer(
         CurrencyName("mok".to_string()), // TODO get currency name
-        key_pair,
+        &self_signator,
         node_id,
         BlockNumber(0), // yet unknown TODO replace when known
         vec![],
@@ -293,7 +296,7 @@ fn init(
     let self_node = MySelfWs2pNode::new(
         node_id,
         key_pair,
-        WS2PFeatures(vec![]),
+        WS2PFeatures([0u8; 4]),
         PeerCard::V11(peer_card),
     );
 
@@ -305,6 +308,7 @@ fn init(
         module_receiver,
         ApiName(constants::API_NAME.to_owned()),
         self_node.clone(),
+        self_signator,
     );
 
     debug!("initialized orchestrators");

lib/modules/ws2p/ws2p/src/services/outgoing.rs

@@ -71,6 +71,7 @@ impl WS2POutgoingOrchestrator {
         currency: CurrencyName,
         ws2p_conf: &WS2PConf,
         self_node: MySelfWs2pNode,
+        self_signator: SignatorEnum,
     ) -> WS2POutgoingOrchestrator {
         // Create service channel
         let (sender, receiver) = mpsc::channel();
@@ -82,6 +83,7 @@ impl WS2POutgoingOrchestrator {
             endpoints_in_error: HashMap::new(),
             never_try_endpoints: Vec::new(),
             self_node,
+            self_signator,
             receiver,
             sender,
         }

lib/modules/ws2p/ws2p/tests/connection_negociation.rs

@@ -62,7 +62,7 @@ fn server_node() -> MySelfWs2pNode {
     // generate peer card
     let peer_card = if let Ok(peer_card) = generate_peer::_generate_self_peer(
         CurrencyName("mok".to_string()),
-        KeyPairEnum::Ed25519(keypair1()),
+        &SignatorEnum::Ed25519(keypair1().generate_signator().expect("corrupted keypair")),
         NodeId(0),
         BlockNumber(0),
         vec![],
@@ -84,7 +84,7 @@ fn client_node() -> MySelfWs2pNode {
     // generate peer card
     let peer_card = if let Ok(peer_card) = generate_peer::_generate_self_peer(
         CurrencyName("mok".to_string()),
-        KeyPairEnum::Ed25519(keypair2()),
+        &SignatorEnum::Ed25519(keypair2().generate_signator().expect("corrupted keypair")),
         NodeId(0),
         BlockNumber(0),
         vec![],