#1-fix typo

src/adapter/api.rs

@@ -48,10 +48,10 @@ async fn handle_command(
     State((tx, _)): State<(Sender<Event>, Receiver<crate::model::state::State>)>,
     extract::Json(message): extract::Json<APICommand>,
 ) -> response::Json<APIResponse> {
-    let (responce_tx, mut responce_rx): (mpsc::Sender<APIResponse>, mpsc::Receiver<APIResponse>) =
+    let (response_tx, mut response_rx): (mpsc::Sender<APIResponse>, mpsc::Receiver<APIResponse>) =
         mpsc::channel(100);
-    let _ = tx.send(Event::APIRequest(message, responce_tx)).await;
-    response::Json(responce_rx.recv().await.unwrap())
+    let _ = tx.send(Event::APIRequest(message, response_tx)).await;
+    response::Json(response_rx.recv().await.unwrap())
 }
 
 async fn handle_query(

src/effect/run.rs

@@ -20,13 +20,13 @@ pub async fn run_effect(state: State, effect: Effect) -> Option<Effect> {
                     id,
                     sign,
                 };
-                return Some(Effect::Broadcast(P2PMessage::ResponceStamp(pk, stamp)));
+                return Some(Effect::Broadcast(P2PMessage::ResponseStamp(pk, stamp)));
             }
         }
         Effect::Broadcast(message) => {
             broadcast(state.peers, message).await;
         }
-        Effect::APIResponce(tx, res) => {
+        Effect::APIResponse(tx, res) => {
             let _ = tx.send(res).await;
         }
     }

src/model/effect.rs

@@ -9,5 +9,5 @@ use crate::{
 pub enum Effect {
     CreateStamp(PK, usize /*difficulty */, usize /*id */),
     Broadcast(P2PMessage),
-    APIResponce(Sender<APIResponse>, APIResponse),
+    APIResponse(Sender<APIResponse>, APIResponse),
 }

src/model/p2p.rs

@@ -10,6 +10,6 @@ pub const P2P_PORT: u32 = 62697;
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub enum P2PMessage {
     RequestStamp(PK, usize /*difficulty */),
-    ResponceStamp(PK, Stamp),
+    ResponseStamp(PK, Stamp),
     UpdateProofpool(ProofPool),
 }

src/update.rs

@@ -12,7 +12,7 @@ pub fn update(state: State, event: Event, time: i64) -> (State, Vec<Effect>) {
                 .collect::<Vec<_>>();
             (state, effects)
         }
-        Event::P2PRequest(P2PMessage::ResponceStamp(pk, stamp)) => {
+        Event::P2PRequest(P2PMessage::ResponseStamp(pk, stamp)) => {
             let state = state.add_to_stamp_pool(stamp);
             let (Some(un_stamped_proof), Some(stamps)) = (
                 state.find_from_un_stamped_proof_pool(&pk),
@@ -61,19 +61,19 @@ pub fn update(state: State, event: Event, time: i64) -> (State, Vec<Effect>) {
                 Ok((un_signed_proof, pk)) => (
                     state.add_to_un_signed_proof_pool(un_signed_proof.clone()),
                     vec![
-                        Effect::APIResponce(tx, APIResponse::Proof(Ok(un_signed_proof.sk))),
+                        Effect::APIResponse(tx, APIResponse::Proof(Ok(un_signed_proof.sk))),
                         Effect::Broadcast(P2PMessage::RequestStamp(pk, un_signed_proof.difficulty)),
                     ],
                 ),
                 Err(_) => (
                     state,
-                    vec![Effect::APIResponce(tx, APIResponse::Proof(Err(())))],
+                    vec![Effect::APIResponse(tx, APIResponse::Proof(Err(())))],
                 ),
             }
         }
         Event::APIRequest(APICommand::AddPeer(ip), tx) => (
             state.add_peer(ip),
-            vec![Effect::APIResponce(tx, APIResponse::AddPeer)],
+            vec![Effect::APIResponse(tx, APIResponse::AddPeer)],
         ),
     }
 }
@@ -125,7 +125,7 @@ mod tests {
     }
 
     #[test]
-    fn p2p_responce_stamp_test() {
+    fn p2p_response_stamp_test() {
         let (pk, _) = generate_pk_and_sk(512).unwrap();
         let create_stamp = |state: State| Stamp {
             address: state.address.clone(),
@@ -136,7 +136,7 @@ mod tests {
             sign: Vec::new(),
         };
         let (state, new_state, effects) = update_test(
-            |state| Event::P2PRequest(P2PMessage::ResponceStamp(pk.clone(), create_stamp(state))),
+            |state| Event::P2PRequest(P2PMessage::ResponseStamp(pk.clone(), create_stamp(state))),
             0,
         );
         assert_eq!(new_state.stamp_pool.len(), 1);