Hsmd2 init msg constructed on hardware itself, broker does not wait for init reply to being

README.md

@@ -22,7 +22,9 @@ Find the path to your `riscv32-esp-elf-gcc` binary within the `.embuild` dir:
 
 ### flash release
 
-`espflash target/riscv32imc-esp-espidf/release/sphinx-key --monitor`
+`esptool.py --chip esp32c3 elf2image target/riscv32imc-esp-espidf/release/sphinx-key`
+
+`esptool.py --chip esp32c3 -p /dev/tty.usbserial-1420 -b 460800 --before=default_reset --after=hard_reset write_flash --flash_mode dio --flash_freq 40m --flash_size 4MB 0x10000 target/riscv32imc-esp-espidf/release/sphinx-key.bin`
 
 ### monitor
 

broker/src/main.rs

@@ -9,7 +9,6 @@ mod util;
 use crate::chain_tracker::MqttSignerPort;
 use crate::mqtt::start_broker;
 use crate::unix_fd::SignerLoop;
-use bitcoin::Network;
 use clap::{arg, App, AppSettings, Arg};
 use std::env;
 use std::sync::Arc;
@@ -54,26 +53,9 @@ fn main() -> anyhow::Result<()> {
         .arg(arg!(--"log-io" "ignored dev flag"))
         .arg(arg!(--version "show a dummy version"))
         .arg(arg!(--test "run a test against the embedded device"))
-        .arg(
-            Arg::new("network")
-                .help("bitcoin network")
-                .long("network")
-                .value_parser(["regtest", "signet", "testnet", "mainnet", "bitcoin"])
-                .default_value("regtest"),
-        );
 
     let matches = app.get_matches();
 
-    let network_string: &String = matches.get_one("network").expect("expected a network");
-    let network: Network = match network_string.as_str() {
-        "bitcoin" => Network::Bitcoin,
-        "mainnet" => Network::Bitcoin,
-        "testnet" => Network::Testnet,
-        "signet" => Network::Signet,
-        "regtest" => Network::Regtest,
-        _ => Network::Regtest,
-    };
-
     if matches.is_present("version") {
         // Pretend to be the right version, given to us by an env var
         let version =
@@ -82,7 +64,6 @@ fn main() -> anyhow::Result<()> {
         return Ok(());
     }
 
-    log::info!("NETWORK: {}", network.to_string());
     if matches.is_present("test") {
         run_test::run_test();
         return Ok(());
@@ -98,8 +79,6 @@ fn main() -> anyhow::Result<()> {
     log::info!("=> connection status: {}", status);
     assert_eq!(status, true, "expected connected = true");
     // runtime.block_on(async {
-    init::blocking_connect(tx.clone(), network);
-    log::info!("=====> sent seed!");
 
     if let Ok(btc_url) = env::var("BITCOIND_RPC_URL") {
         let signer_port = MqttSignerPort::new(tx.clone());

signer/src/lib.rs

@@ -1,14 +1,15 @@
 use lightning_signer::persist::{DummyPersister, Persist};
 // use lightning_signer::Arc;
-use sphinx_key_parser::MsgDriver;
 use std::sync::Arc;
 use vls_protocol::model::PubKey;
 use vls_protocol::msgs::{self, read_serial_request_header, write_serial_response_header, Message};
 use vls_protocol::serde_bolt::WireString;
 use vls_protocol_signer::handler::{Handler, RootHandler};
+
 pub use vls_protocol_signer::lightning_signer;
 pub use vls_protocol_signer::lightning_signer::bitcoin::Network;
 pub use vls_protocol_signer::vls_protocol;
+pub use sphinx_key_parser::MsgDriver;
 
 pub struct InitResponse {
     pub root_handler: RootHandler,

sphinx-key/src/core/events.rs

@@ -1,4 +1,6 @@
 use crate::conn::mqtt::{QOS, RETURN_TOPIC, TOPIC};
+use crate::core::init::make_init_msg;
+
 use sphinx_key_signer::vls_protocol::model::PubKey;
 use sphinx_key_signer::{self, InitResponse};
 use sphinx_key_signer::lightning_signer::bitcoin::Network;
@@ -36,35 +38,35 @@ pub fn make_event_loop(
     rx: mpsc::Receiver<Event>,
     network: Network,
     do_log: bool,
-    led_tx: mpsc::Sender<Status>
+    led_tx: mpsc::Sender<Status>,
+    seed: [u8; 32]
 ) -> Result<()> {
-    // initialize the RootHandler
-    let root_handler = loop {
-        if let Ok(event) = rx.recv() {
-            match event {
-                Event::Connected => {
-                    log::info!("SUBSCRIBE to {}", TOPIC);
-                    mqtt.subscribe(TOPIC, QOS)
-                        .expect("could not MQTT subscribe");
-                    led_tx.send(Status::Connected).unwrap();
-                }
-                Event::Message(ref msg_bytes) => {
-                    let InitResponse {
-                        root_handler,
-                        init_reply,
-                    } = sphinx_key_signer::init(msg_bytes.clone(), network).expect("failed to init signer");
-                    mqtt.publish(RETURN_TOPIC, QOS, false, init_reply)
-                        .expect("could not publish init response");
-                    break root_handler;
-                }
-                Event::Disconnected => {
-                    led_tx.send(Status::ConnectingToMqtt).unwrap();
-                    log::info!("GOT an early Event::Disconnected msg!");
-                }
+    while let Ok(event) = rx.recv() {
+        match event {
+            Event::Connected => {
+                log::info!("SUBSCRIBE to {}", TOPIC);
+                mqtt.subscribe(TOPIC, QOS)
+                    .expect("could not MQTT subscribe");
+                led_tx.send(Status::Connected).unwrap();
+                break;
+            }
+            Event::Message(ref _msg_bytes) => {
+                panic!("should not be a message before connection");
+            }
+            Event::Disconnected => {
+                led_tx.send(Status::ConnectingToMqtt).unwrap();
+                log::info!("GOT an early Event::Disconnected msg!");
             }
         }
-    };
+    }
 
+    // initialize the RootHandler
+    let init_msg = make_init_msg(network, seed).expect("failed to make init msg");
+    let InitResponse {
+        root_handler,
+        init_reply: _,
+    } = sphinx_key_signer::init(init_msg, network).expect("failed to init signer");
+    
     // signing loop
     let dummy_peer = PubKey([0; 33]);
     while let Ok(event) = rx.recv() {
@@ -105,7 +107,8 @@ pub fn make_event_loop(
     rx: mpsc::Receiver<Event>,
     _network: Network,
     do_log: bool,
-    led_tx: mpsc::Sender<Status>
+    led_tx: mpsc::Sender<Status>,
+    _seed: [u8; 32]
 ) -> Result<()> {
     log::info!("About to subscribe to the mpsc channel");
     while let Ok(event) = rx.recv() {

sphinx-key/src/core/init.rs

@@ -0,0 +1,20 @@
+use sphinx_key_signer::MsgDriver;
+use sphinx_key_signer::vls_protocol::model::Secret;
+use sphinx_key_signer::vls_protocol::{msgs, serde_bolt::WireString};
+use sphinx_key_signer::lightning_signer::bitcoin::Network;
+
+pub fn make_init_msg(network: Network, seed: [u8; 32]) -> anyhow::Result<Vec<u8>> {
+    let allowlist = Vec::new();
+    log::info!("allowlist {:?} seed {:?}", allowlist, seed);
+    let init = msgs::HsmdInit2 {
+        derivation_style: 0,
+        network_name: WireString(network.to_string().as_bytes().to_vec()),
+        dev_seed: Some(Secret(seed)),
+        dev_allowlist: allowlist,
+    };
+    let sequence = 0;
+    let mut md = MsgDriver::new_empty();
+    msgs::write_serial_request_header(&mut md, sequence, 0)?;
+    msgs::write(&mut md, init)?;
+    Ok(md.bytes())
+}

sphinx-key/src/core/mod.rs

@@ -1,2 +1,3 @@
 pub mod events;
 pub mod config;
+pub mod init;

sphinx-key/src/main.rs

@@ -65,7 +65,6 @@ fn main() -> Result<()> {
         let (mqtt, connection) = conn::mqtt::make_client(&exist.broker, CLIENT_ID)?;
         let mqtt_client = conn::mqtt::start_listening(mqtt, connection, tx)?;
         // this blocks forever... the "main thread"
-        log::info!(">>>>>>>>>>> blocking forever...");
         let do_log = true;
         let network = match exist.network.as_str() {
             "bitcoin" => Network::Bitcoin,
@@ -76,7 +75,8 @@ fn main() -> Result<()> {
             _ => Network::Regtest,
         };
         log::info!("Network set to {:?}", network);
-        make_event_loop(mqtt_client, rx, network, do_log, led_tx)?;
+        log::info!(">>>>>>>>>>> blocking forever...");
+        make_event_loop(mqtt_client, rx, network, do_log, led_tx, exist.seed)?;
     } else {
         led_tx.send(Status::WifiAccessPoint).unwrap();
         println!("=============> START SERVER NOW AND WAIT <==============");