(feat): rename example-usage to just example

(feat): add the example's web-client dist folder to a gitignore
(fix): format issues
(fix): a lot of duplicate code

wasm/src/client.rs

@@ -103,6 +103,33 @@ fn verify_host_final(
     Ok(())
 }
 
+fn random_nonce() -> Result<u128, JsValue> {
+    let mut nonce_bytes = [0u8; 16];
+    getrandom::fill(&mut nonce_bytes).map_err(|_| js_error("rng failed"))?;
+    Ok(u128::from_be_bytes(nonce_bytes))
+}
+
+fn signed_challenge_response_bytes(
+    keyring: &mtp_crypto::Keyring,
+    proof_payload: &[u8],
+    client_nonce: u128,
+) -> Result<Vec<u8>, JsValue> {
+    let signer = mtp_crypto::Ed25519Signer::new(&keyring.sig_cl_secret_key)
+        .map_err(|e| js_error(&format!("signer creation failed: {}", e)))?;
+    let signature = signer
+        .sign(proof_payload)
+        .map_err(|e| js_error(&format!("signature failed: {}", e)))?;
+
+    CommunicationValue::new(CommunicationType::ChallengeResponse)
+        .add_typed_default(
+            DataType::ClientNonce,
+            DataValue::UnsignedNumber(client_nonce),
+        )
+        .add_typed_default(DataType::Signature, DataValue::Bytes(signature))
+        .to_bytes()
+        .map_err(|e| js_error(&format!("encode failed: {}", e)))
+}
+
 #[wasm_bindgen]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ConnectionState {
@@ -206,17 +233,7 @@ impl WasmClient {
             .map_err(|e| js_error(&format!("encode failed: {}", e)))?;
         transport.send_frame(&ident_bytes).await?;
 
-        let loop_transport = transport.clone();
-        self.transport = Some(transport);
-        self.set_state(ConnectionState::Connected);
-
-        let state = self.state.clone();
-        let on_msg = self.on_message.clone();
-        let on_err = self.on_error.clone();
-        wasm_bindgen_futures::spawn_local(async move {
-            loop_transport.receive_loop(on_msg, on_err).await;
-            state.set(ConnectionState::Disconnected);
-        });
+        self.start_receive_loop(transport);
         Ok(())
     }
 
@@ -258,38 +275,18 @@ impl WasmClient {
         transport.send_frame(&hello).await?;
 
         // 2. Receive and verify the host's challenge.
-        let challenge_bytes = transport.read_one_frame().await?;
-        let challenge = CommunicationValue::from_bytes(&challenge_bytes)
-            .map_err(|e| js_error(&format!("parse challenge: {}", e)))?;
-        let expected = CommunicationType::Challenge.to_id(&tm);
-        if challenge.get_type() != expected {
-            self.set_state(ConnectionState::Disconnected);
-            return Err(unexpected_response_type_error(
+        let server_challenge = self
+            .read_verified_challenge(
+                &transport,
+                &tm,
+                &host_pk,
+                client_id,
                 "auth_connect challenge",
-                expected,
-                challenge.get_type(),
-                &challenge_bytes,
-                &challenge,
-            ));
-        }
-        let server_challenge = match challenge.get_data(DataType::ServerNonce.to_id(&tm)) {
-            DataValue::UnsignedNumber(n) => *n,
-            _ => {
-                self.set_state(ConnectionState::Disconnected);
-                return Err(js_error("missing server challenge"));
-            }
-        };
-        if let Err(e) =
-            verify_host_challenge(&challenge, &tm, &host_pk, client_id, server_challenge)
-        {
-            self.set_state(ConnectionState::Disconnected);
-            return Err(e);
-        }
+            )
+            .await?;
 
         // 3. Sign the host's challenge and send the proof.
-        let mut nonce_bytes = [0u8; 16];
-        getrandom::fill(&mut nonce_bytes).map_err(|_| js_error("rng failed"))?;
-        let client_nonce = u128::from_be_bytes(nonce_bytes);
+        let client_nonce = random_nonce()?;
 
         let proof_payload = mtp_crypto::auth::login_proof_payload(
             &version_str,
@@ -297,20 +294,7 @@ impl WasmClient {
             server_challenge,
             client_nonce,
         );
-        let signer = mtp_crypto::Ed25519Signer::new(&keyring.sig_cl_secret_key)
-            .map_err(|e| js_error(&format!("signer creation failed: {}", e)))?;
-        let signature = signer
-            .sign(&proof_payload)
-            .map_err(|e| js_error(&format!("signature failed: {}", e)))?;
-
-        let proof = CommunicationValue::new(CommunicationType::ChallengeResponse)
-            .add_typed_default(
-                DataType::ClientNonce,
-                DataValue::UnsignedNumber(client_nonce),
-            )
-            .add_typed_default(DataType::Signature, DataValue::Bytes(signature))
-            .to_bytes()
-            .map_err(|e| js_error(&format!("encode failed: {}", e)))?;
+        let proof = signed_challenge_response_bytes(&keyring, &proof_payload, client_nonce)?;
         transport.send_frame(&proof).await?;
 
         // 4. Receive and verify the host's final confirmation.
@@ -357,17 +341,7 @@ impl WasmClient {
             }
         };
 
-        let loop_transport = transport.clone();
-        self.transport = Some(transport);
-        self.set_state(ConnectionState::Connected);
-
-        let state = self.state.clone();
-        let on_msg = self.on_message.clone();
-        let on_err = self.on_error.clone();
-        wasm_bindgen_futures::spawn_local(async move {
-            loop_transport.receive_loop(on_msg, on_err).await;
-            state.set(ConnectionState::Disconnected);
-        });
+        self.start_receive_loop(transport);
 
         Ok(assigned_id)
     }
@@ -409,36 +383,12 @@ impl WasmClient {
         transport.send_frame(&hello).await?;
 
         // 2. Receive and verify the host's challenge (register binds id = 0).
-        let challenge_bytes = transport.read_one_frame().await?;
-        let challenge = CommunicationValue::from_bytes(&challenge_bytes)
-            .map_err(|e| js_error(&format!("parse challenge: {}", e)))?;
-        let expected = CommunicationType::Challenge.to_id(&tm);
-        if challenge.get_type() != expected {
-            self.set_state(ConnectionState::Disconnected);
-            return Err(unexpected_response_type_error(
-                "auth_register challenge",
-                expected,
-                challenge.get_type(),
-                &challenge_bytes,
-                &challenge,
-            ));
-        }
-        let server_challenge = match challenge.get_data(DataType::ServerNonce.to_id(&tm)) {
-            DataValue::UnsignedNumber(n) => *n,
-            _ => {
-                self.set_state(ConnectionState::Disconnected);
-                return Err(js_error("missing server challenge"));
-            }
-        };
-        if let Err(e) = verify_host_challenge(&challenge, &tm, &host_pk, 0, server_challenge) {
-            self.set_state(ConnectionState::Disconnected);
-            return Err(e);
-        }
+        let server_challenge = self
+            .read_verified_challenge(&transport, &tm, &host_pk, 0, "auth_register challenge")
+            .await?;
 
         // 3. Sign the host's challenge over the bundle and send the proof.
-        let mut nonce_bytes = [0u8; 16];
-        getrandom::fill(&mut nonce_bytes).map_err(|_| js_error("rng failed"))?;
-        let client_nonce = u128::from_be_bytes(nonce_bytes);
+        let client_nonce = random_nonce()?;
 
         let proof_payload = mtp_crypto::auth::register_proof_payload(
             &version_str,
@@ -446,20 +396,7 @@ impl WasmClient {
             server_challenge,
             client_nonce,
         );
-        let signer = mtp_crypto::Ed25519Signer::new(&keyring.sig_cl_secret_key)
-            .map_err(|e| js_error(&format!("signer creation failed: {}", e)))?;
-        let signature = signer
-            .sign(&proof_payload)
-            .map_err(|e| js_error(&format!("signature failed: {}", e)))?;
-
-        let proof = CommunicationValue::new(CommunicationType::ChallengeResponse)
-            .add_typed_default(
-                DataType::ClientNonce,
-                DataValue::UnsignedNumber(client_nonce),
-            )
-            .add_typed_default(DataType::Signature, DataValue::Bytes(signature))
-            .to_bytes()
-            .map_err(|e| js_error(&format!("encode failed: {}", e)))?;
+        let proof = signed_challenge_response_bytes(&keyring, &proof_payload, client_nonce)?;
         transport.send_frame(&proof).await?;
 
         // 4. Receive the host's final confirmation; extract + verify assigned id.
@@ -505,17 +442,7 @@ impl WasmClient {
             return Err(e);
         }
 
-        let loop_transport = transport.clone();
-        self.transport = Some(transport);
-        self.set_state(ConnectionState::Connected);
-
-        let state = self.state.clone();
-        let on_msg = self.on_message.clone();
-        let on_err = self.on_error.clone();
-        wasm_bindgen_futures::spawn_local(async move {
-            loop_transport.receive_loop(on_msg, on_err).await;
-            state.set(ConnectionState::Disconnected);
-        });
+        self.start_receive_loop(transport);
 
         Ok(assigned_id)
     }
@@ -543,4 +470,57 @@ impl WasmClient {
             .on_state_change
             .call1(&JsValue::NULL, &JsValue::from(new_state as u8));
     }
+
+    fn start_receive_loop(&mut self, transport: WasmTransport) {
+        let loop_transport = transport.clone();
+        self.transport = Some(transport);
+        self.set_state(ConnectionState::Connected);
+
+        let state = self.state.clone();
+        let on_msg = self.on_message.clone();
+        let on_err = self.on_error.clone();
+        wasm_bindgen_futures::spawn_local(async move {
+            loop_transport.receive_loop(on_msg, on_err).await;
+            state.set(ConnectionState::Disconnected);
+        });
+    }
+
+    async fn read_verified_challenge(
+        &self,
+        transport: &WasmTransport,
+        tm: &mtp_codec::TypeMap,
+        host_pk: &mtp_crypto::PublicKeyBundle,
+        bound_id: u64,
+        context: &str,
+    ) -> Result<u128, JsValue> {
+        let challenge_bytes = transport.read_one_frame().await?;
+        let challenge = CommunicationValue::from_bytes(&challenge_bytes)
+            .map_err(|e| js_error(&format!("parse challenge: {}", e)))?;
+        let expected = CommunicationType::Challenge.to_id(tm);
+        if challenge.get_type() != expected {
+            self.set_state(ConnectionState::Disconnected);
+            return Err(unexpected_response_type_error(
+                context,
+                expected,
+                challenge.get_type(),
+                &challenge_bytes,
+                &challenge,
+            ));
+        }
+
+        let server_challenge = match challenge.get_data(DataType::ServerNonce.to_id(tm)) {
+            DataValue::UnsignedNumber(n) => *n,
+            _ => {
+                self.set_state(ConnectionState::Disconnected);
+                return Err(js_error("missing server challenge"));
+            }
+        };
+
+        if let Err(e) = verify_host_challenge(&challenge, tm, host_pk, bound_id, server_challenge) {
+            self.set_state(ConnectionState::Disconnected);
+            return Err(e);
+        }
+
+        Ok(server_challenge)
+    }
 }

wasm/src/message.rs

@@ -2,7 +2,7 @@ use wasm_bindgen::prelude::*;
 
 use mtp_codec::{CommunicationType, CommunicationValue, DataType, DataTypeId, DataValue};
 use mtp_crypto::{Ed25519Signer, EncryptionType, Keyring, PublicKeyBundle, SigAlgorithm};
-use mtp_type_map::{communication_type_name, TypeMap};
+use mtp_type_map::{TypeMap, communication_type_name};
 
 use crate::error::js_error;
 
@@ -54,8 +54,14 @@ pub fn build_demo_message(
 
     // Encrypted container
     let inner_enc = DataValue::Container(vec![
-        (DataType::Version.to_id(&TypeMap::latest()), DataValue::Str("secret inner data".into())),
-        (DataType::Id.to_id(&TypeMap::latest()), DataValue::UnsignedNumber(42)),
+        (
+            DataType::Version.to_id(&TypeMap::latest()),
+            DataValue::Str("secret inner data".into()),
+        ),
+        (
+            DataType::Id.to_id(&TypeMap::latest()),
+            DataValue::UnsignedNumber(42),
+        ),
     ]);
     let mut dv_enc = inner_enc;
     dv_enc
@@ -64,8 +70,14 @@ pub fn build_demo_message(
 
     // Signed container
     let inner_sig = DataValue::Container(vec![
-        (DataType::Version.to_id(&TypeMap::latest()), DataValue::Str("signed by client".into())),
-        (DataType::Id.to_id(&TypeMap::latest()), DataValue::UnsignedNumber(99)),
+        (
+            DataType::Version.to_id(&TypeMap::latest()),
+            DataValue::Str("signed by client".into()),
+        ),
+        (
+            DataType::Id.to_id(&TypeMap::latest()),
+            DataValue::UnsignedNumber(99),
+        ),
     ]);
     let mut dv_sig = inner_sig;
     dv_sig
@@ -78,7 +90,10 @@ pub fn build_demo_message(
             DataType::Version.to_id(&TypeMap::latest()),
             DataValue::Str("signed+encrypted payload".into()),
         ),
-        (DataType::Id.to_id(&TypeMap::latest()), DataValue::UnsignedNumber(7)),
+        (
+            DataType::Id.to_id(&TypeMap::latest()),
+            DataValue::UnsignedNumber(7),
+        ),
     ]);
     let mut dv_sec = inner_sec;
     dv_sec
@@ -115,7 +130,10 @@ pub fn parse_auth_response(response: &[u8]) -> Result<JsValue, JsValue> {
     let comm = CommunicationValue::from_bytes(response)
         .map_err(|e| js_error(&format!("parse failed: {}", e)))?;
 
-    let connected = matches!(comm.get_data(DataType::Connected.to_id(&TypeMap::latest())), DataValue::BoolTrue);
+    let connected = matches!(
+        comm.get_data(DataType::Connected.to_id(&TypeMap::latest())),
+        DataValue::BoolTrue
+    );
 
     let client_nonce = match comm.get_data(DataType::ClientNonce.to_id(&TypeMap::latest())) {
         DataValue::UnsignedNumber(n) => Some(*n),
@@ -279,7 +297,10 @@ mod tests {
             cv.get_data(DataType::Description.to_id(&tm)),
             &DataValue::Str("with-data".into())
         );
-        assert_eq!(cv.get_data(DataType::Timestamp.to_id(&tm)), &DataValue::UnsignedNumber(555));
+        assert_eq!(
+            cv.get_data(DataType::Timestamp.to_id(&tm)),
+            &DataValue::UnsignedNumber(555)
+        );
         assert_eq!(
             cv.get_data(DataType::Id.to_id(&tm)),
             &DataValue::Bytes(payload.to_vec())

wasm/src/transport.rs

@@ -51,10 +51,18 @@ enum FrameOutcome {
  *   [11..]   id/sender/receiver/signature/data, gated by `flags`
  */
 fn log_frame_bytes(wire: &[u8]) {
-    let hex: String = wire.iter().map(|b| format!("{b:02x}")).collect::<Vec<_>>().join(" ");
+    let hex: String = wire
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect::<Vec<_>>()
+        .join(" ");
 
-    let outer_len = wire.get(0..4).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
-    let inner_len = wire.get(4..8).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
+    let outer_len = wire
+        .get(0..4)
+        .map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
+    let inner_len = wire
+        .get(4..8)
+        .map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
     let comm_type = wire.get(8..10).map(|b| u16::from_be_bytes([b[0], b[1]]));
     let flags = wire.get(10).copied();