hardware lss initialization

sphinx-key/src/core/events.rs

@@ -1,4 +1,5 @@
 use crate::conn::mqtt::QOS;
+use crate::core::lss;
 use crate::ota::{update_sphinx_key, validate_ota_message};
 
 use sphinx_signer::lightning_signer::bitcoin::Network;
@@ -94,9 +95,20 @@ pub fn make_event_loop(
     let persister: Arc<dyn Persist> = Arc::new(FsPersister::new(&ROOT_STORE, Some(8)));
 
     // initialize the RootHandler
-    let handler_builder = sphinx_signer::root::builder(seed, network, policy, persister)
+    let hb = sphinx_signer::root::builder(seed, network, policy, persister)
         .expect("failed to init signer");
-    let (root_handler, _) = handler_builder.build();
+
+    // FIXME it right to restart here?
+    let (root_handler, lss_signer) = match lss::init_lss(client_id, &rx, hb, &mut mqtt) {
+        Ok(rl) => rl,
+        Err(e) => {
+            log::error!("failed to init lss {:?}", e);
+            unsafe { esp_idf_sys::esp_restart() };
+            panic!("faild to init lss");
+        }
+    };
+
+    // let (root_handler, _) = handler_builder.build();
 
     // signing loop
     log::info!("=> starting the main signing loop...");

sphinx-key/src/core/lss.rs

@@ -1,8 +1,41 @@
+use crate::conn::mqtt::QOS;
+use crate::core::events::Event;
 use anyhow::{anyhow, Result};
+use embedded_svc::mqtt::client::MessageImpl;
+use embedded_svc::utils::mqtt::client::ConnState;
+use esp_idf_svc::mqtt::client::EspMqttClient;
+use esp_idf_sys::EspError;
 use lss_connector::{secp256k1::PublicKey, LssSigner, Msg as LssMsg, Response as LssRes};
+use sphinx_signer::sphinx_glyph::topics;
 use sphinx_signer::{self, RootHandler, RootHandlerBuilder};
+use std::sync::mpsc;
 
-pub fn init_lss() -> Result<(RootHandler, LssSigner)> {
+pub fn init_lss(
-    let init = LssMsg::from_slice(&[0])?.as_init()?;
+    client_id: &str,
-    Err(anyhow!("test"))
+    rx: &mpsc::Receiver<Event>,
+    handler_builder: RootHandlerBuilder,
+    mqtt: &mut EspMqttClient<ConnState<MessageImpl, EspError>>,
+) -> Result<(RootHandler, LssSigner)> {
+    let first_lss_msg = match rx.recv()? {
+        Event::LssMessage(b) => b,
+        _ => return Err(anyhow!("not a lss msg")),
+    };
+    let init = LssMsg::from_slice(&first_lss_msg)?.as_init()?;
+    let server_pubkey = PublicKey::from_slice(&init.server_pubkey)?;
+
+    let (lss_signer, res1) = LssSigner::new(&handler_builder, &server_pubkey);
+    let lss_res_topic = format!("{}/{}", client_id, topics::LSS_RES);
+    mqtt.publish(&lss_res_topic, QOS, false, &res1)
+        .expect("could not publish LSS response");
+
+    let second_lss_msg = match rx.recv()? {
+        Event::LssMessage(b) => b,
+        _ => return Err(anyhow!("not a lss msg")),
+    };
+    let created = LssMsg::from_slice(&second_lss_msg)?.as_created()?;
+    let (root_handler, res2) = lss_signer.build_with_lss(created, handler_builder)?;
+    mqtt.publish(&lss_res_topic, QOS, false, &res2)
+        .expect("could not publish LSS response 2");
+
+    Ok((root_handler, lss_signer))
 }