aljaz/sphinx-key
1
1
Fork 0
mirror of https://github.com/stakwork/sphinx-key.git synced 2025-12-17 15:24:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix broker init on release

Browse Source
This commit is contained in:
Evan Feenstra
2022-06-16 09:24:11 -07:00
parent 908c0b5186
commit 209dda952a
6 changed files with 109 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -14,7 +14,7 @@ Find the path to your `riscv32-esp-elf-gcc` binary within the `.embuild` dir:
### flash test ### flash test
`espflash target/riscv32imc-esp-espidf/debug/sphinx-key` `espflash target/riscv32imc-esp-espidf/debug/sphinx-key --monitor`
### build release ### build release

10
broker/src/main.rs
View File

@@ -60,10 +60,18 @@ fn main() -> anyhow::Result<()> {
run_test::run_test(); run_test::run_test();
} else { } else {
let (tx, rx) = mpsc::channel(1000); let (tx, rx) = mpsc::channel(1000);
let (status_tx, _status_rx) = mpsc::channel(1000); let (status_tx, mut status_rx) = mpsc::channel(1000);
log::info!("=> start broker");
let _runtime = start_broker(rx, status_tx, "sphinx-1"); let _runtime = start_broker(rx, status_tx, "sphinx-1");
log::info!("=> wait for connected status");
// wait for connection = true
let status = status_rx.blocking_recv().expect("couldnt receive");
log::info!("=> connection status: {}", status);
assert_eq!(status, true, "expected connected = true");
// runtime.block_on(async { // runtime.block_on(async {
init::blocking_connect(tx.clone()); init::blocking_connect(tx.clone());
log::info!("=====> sent seed!");
// listen to reqs from CLN // listen to reqs from CLN
let conn = UnixConnection::new(parent_fd); let conn = UnixConnection::new(parent_fd);
let client = UnixClient::new(conn); let client = UnixClient::new(conn);

4
signer/Cargo.toml
View File

@@ -6,11 +6,9 @@ edition = "2018"
[dependencies] [dependencies]
sphinx-key-parser = { path = "../parser" } sphinx-key-parser = { path = "../parser" }
# vls-protocol-signer = { path = "../../../evanf/validating-lightning-signer/vls-protocol-signer", default-features = false, features = ["secp-lowmemory"] }
vls-protocol-signer = { git = "https://gitlab.com/lightning-signer/validating-lightning-signer", default-features = false, features = ["secp-lowmemory"] } vls-protocol-signer = { git = "https://gitlab.com/lightning-signer/validating-lightning-signer", default-features = false, features = ["secp-lowmemory"] }
anyhow = {version = "1", features = ["backtrace"]} anyhow = {version = "1", features = ["backtrace"]}
log = "0.4" log = "0.4"
[patch.crates-io]
# Low-memory version of secp256k1 with static precomputation
secp256k1 = { git = "https://github.com/devrandom/rust-secp256k1.git", rev = "4e745ebe7e4c9cd0a7e9c8d5c42e989522e52f71" }

3
signer/src/lib.rs
View File

@@ -26,8 +26,11 @@ pub fn init(bytes: Vec<u8>) -> anyhow::Result<InitResponse> {
.iter() .iter()
.map(|s| from_wire_string(s)) .map(|s| from_wire_string(s))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
log::info!("allowlist {:?}", allowlist);
let seed = init.dev_seed.as_ref().map(|s| s.0).expect("no seed"); let seed = init.dev_seed.as_ref().map(|s| s.0).expect("no seed");
log::info!("seed {:?}", seed);
let root_handler = RootHandler::new(0, Some(seed), persister, allowlist); let root_handler = RootHandler::new(0, Some(seed), persister, allowlist);
log::info!("root_handler created");
let init_reply = root_handler let init_reply = root_handler
.handle(Message::HsmdInit2(init)) .handle(Message::HsmdInit2(init))
.expect("handle init"); .expect("handle init");

49
sphinx-key/src/conn/mqtt.rs
View File

@@ -1,16 +1,16 @@
use crate::core::events::Event as CoreEvent; use crate::core::events::Event as CoreEvent;
use embedded_svc::mqtt::client::utils::ConnState;
use embedded_svc::mqtt::client::{Connection, MessageImpl, QoS, Event, Message as MqttMessage};
use embedded_svc::mqtt::client::utils::Connection as MqttConnection;
use esp_idf_svc::mqtt::client::*;
use anyhow::Result; use anyhow::Result;
use log::*; use embedded_svc::mqtt::client::utils::ConnState;
use std::thread; use embedded_svc::mqtt::client::utils::Connection as MqttConnection;
use esp_idf_sys::{self}; use embedded_svc::mqtt::client::{Connection, Event, Message as MqttMessage, MessageImpl, QoS};
use esp_idf_sys::EspError;
use esp_idf_hal::mutex::Condvar; use esp_idf_hal::mutex::Condvar;
use std::sync::{mpsc}; use esp_idf_svc::mqtt::client::*;
use esp_idf_sys::EspError;
use esp_idf_sys::{self};
use log::*;
use std::sync::mpsc;
use std::thread;
pub const TOPIC: &str = "sphinx"; pub const TOPIC: &str = "sphinx";
pub const RETURN_TOPIC: &str = "sphinx-return"; pub const RETURN_TOPIC: &str = "sphinx-return";
@@ -18,10 +18,14 @@ pub const USERNAME: &str = "sphinx-key";
pub const PASSWORD: &str = "sphinx-key-pass"; pub const PASSWORD: &str = "sphinx-key-pass";
pub const QOS: QoS = QoS::AtMostOnce; pub const QOS: QoS = QoS::AtMostOnce;
pub fn make_client(broker: &str, client_id: &str) -> Result<( pub fn make_client(
broker: &str,
client_id: &str,
) -> Result<(
EspMqttClient<ConnState<MessageImpl, EspError>>, EspMqttClient<ConnState<MessageImpl, EspError>>,
MqttConnection<Condvar, MessageImpl, EspError>, MqttConnection<Condvar, MessageImpl, EspError>,
)> { )> {
log::info!("make_client with id {}", client_id);
let conf = MqttClientConfiguration { let conf = MqttClientConfiguration {
client_id: Some(client_id), client_id: Some(client_id),
buffer_size: 2048, buffer_size: 2048,
@@ -47,39 +51,38 @@ pub fn start_listening(
mut connection: MqttConnection<Condvar, MessageImpl, EspError>, mut connection: MqttConnection<Condvar, MessageImpl, EspError>,
tx: mpsc::Sender<CoreEvent>, tx: mpsc::Sender<CoreEvent>,
) -> Result<EspMqttClient<ConnState<MessageImpl, EspError>>> { ) -> Result<EspMqttClient<ConnState<MessageImpl, EspError>>> {
// must start pumping before subscribe or publish will not work // must start pumping before subscribe or publish will not work
thread::spawn(move || { thread::spawn(move || {
info!("MQTT Listening for messages"); info!("MQTT Listening for messages");
loop { loop {
match connection.next() { match connection.next() {
Some(msg) => { Some(msg) => match msg {
match msg {
Err(e) => match e.to_string().as_ref() { Err(e) => match e.to_string().as_ref() {
"ESP_FAIL" => { "ESP_FAIL" => {
error!("ESP_FAIL msg!"); error!("ESP_FAIL msg!");
}, }
_ => error!("Unknown error: {}", e), _ => error!("Unknown error: {}", e),
}, },
Ok(msg) => { Ok(msg) => match msg {
match msg {
Event::BeforeConnect => info!("RECEIVED BeforeConnect MESSAGE"), Event::BeforeConnect => info!("RECEIVED BeforeConnect MESSAGE"),
Event::Connected(_flag) => { Event::Connected(_flag) => {
info!("RECEIVED Connected MESSAGE"); info!("RECEIVED Connected MESSAGE");
tx.send(CoreEvent::Connected).expect("couldnt send Event::Connected"); tx.send(CoreEvent::Connected)
}, .expect("couldnt send Event::Connected");
}
Event::Disconnected => { Event::Disconnected => {
warn!("RECEIVED Disconnected MESSAGE"); warn!("RECEIVED Disconnected MESSAGE");
tx.send(CoreEvent::Disconnected).expect("couldnt send Event::Disconnected"); tx.send(CoreEvent::Disconnected)
}, .expect("couldnt send Event::Disconnected");
}
Event::Subscribed(_mes_id) => info!("RECEIVED Subscribed MESSAGE"), Event::Subscribed(_mes_id) => info!("RECEIVED Subscribed MESSAGE"),
Event::Unsubscribed(_mes_id) => info!("RECEIVED Unsubscribed MESSAGE"), Event::Unsubscribed(_mes_id) => info!("RECEIVED Unsubscribed MESSAGE"),
Event::Published(_mes_id) => info!("RECEIVED Published MESSAGE"), Event::Published(_mes_id) => info!("RECEIVED Published MESSAGE"),
Event::Received(msg) => tx.send(CoreEvent::Message(msg.data().to_vec())).expect("couldnt send Event::Message"), Event::Received(msg) => tx
.send(CoreEvent::Message(msg.data().to_vec()))
.expect("couldnt send Event::Message"),
Event::Deleted(_mes_id) => info!("RECEIVED Deleted MESSAGE"), Event::Deleted(_mes_id) => info!("RECEIVED Deleted MESSAGE"),
}
}, },
}
}, },
None => break, None => break,
} }

74
sphinx-key/src/core/events.rs
View File

@@ -1,32 +1,49 @@
use crate::conn::mqtt::{RETURN_TOPIC, TOPIC, QOS}; use crate::conn::mqtt::{QOS, RETURN_TOPIC, TOPIC};
use sphinx_key_signer::{self, InitResponse};
use sphinx_key_signer::vls_protocol::model::PubKey; use sphinx_key_signer::vls_protocol::model::PubKey;
use sphinx_key_signer::{self, InitResponse};
use std::sync::mpsc; use std::sync::mpsc;
use esp_idf_sys;
use embedded_svc::mqtt::client::Client;
use embedded_svc::httpd::Result; use embedded_svc::httpd::Result;
use embedded_svc::mqtt::client::utils::ConnState; use embedded_svc::mqtt::client::utils::ConnState;
use embedded_svc::mqtt::client::Client;
use embedded_svc::mqtt::client::{MessageImpl, Publish}; use embedded_svc::mqtt::client::{MessageImpl, Publish};
use esp_idf_svc::mqtt::client::*; use esp_idf_svc::mqtt::client::*;
use esp_idf_sys;
use esp_idf_sys::EspError; use esp_idf_sys::EspError;
pub enum Event { pub enum Event {
Connected, Connected,
Disconnected, Disconnected,
Message(Vec<u8>) Message(Vec<u8>),
} }
#[cfg(not(feature = "pingpong"))] #[cfg(not(feature = "pingpong"))]
pub fn make_event_loop(mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>, rx: mpsc::Receiver<Event>, do_log: bool) -> Result<()> { pub fn make_event_loop(
mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>,
rx: mpsc::Receiver<Event>,
do_log: bool,
) -> Result<()> {
// initialize the RootHandler // initialize the RootHandler
let root_handler = loop { let root_handler = loop {
if let Ok(event) = rx.recv() { if let Ok(event) = rx.recv() {
if let Event::Message(msg_bytes) = event { match event {
let InitResponse { root_handler, init_reply } = sphinx_key_signer::init(msg_bytes).expect("failed to init signer"); Event::Connected => {
mqtt.publish(RETURN_TOPIC, QOS, false, init_reply).expect("could not publish init response"); log::info!("SUBSCRIBE to {}", TOPIC);
break root_handler mqtt.subscribe(TOPIC, QOS)
.expect("could not MQTT subscribe");
}
Event::Message(ref msg_bytes) => {
let InitResponse {
root_handler,
init_reply,
} = sphinx_key_signer::init(msg_bytes.clone()).expect("failed to init signer");
mqtt.publish(RETURN_TOPIC, QOS, false, init_reply)
.expect("could not publish init response");
break root_handler;
}
Event::Disconnected => {
log::info!("GOT an early Event::Disconnected msg!");
}
} }
} }
}; };
@@ -37,14 +54,22 @@ pub fn make_event_loop(mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>
match event { match event {
Event::Connected => { Event::Connected => {
log::info!("SUBSCRIBE TO {}", TOPIC); log::info!("SUBSCRIBE TO {}", TOPIC);
mqtt.subscribe(TOPIC, QOS).expect("could not MQTT subscribe"); mqtt.subscribe(TOPIC, QOS)
}, .expect("could not MQTT subscribe");
}
Event::Message(ref msg_bytes) => { Event::Message(ref msg_bytes) => {
let _ret = match sphinx_key_signer::handle(&root_handler, msg_bytes.clone(), dummy_peer.clone(), do_log) { let _ret = match sphinx_key_signer::handle(
Ok(b) => mqtt.publish(RETURN_TOPIC, QOS, false, b).expect("could not publish init response"), &root_handler,
msg_bytes.clone(),
dummy_peer.clone(),
do_log,
) {
Ok(b) => mqtt
.publish(RETURN_TOPIC, QOS, false, b)
.expect("could not publish init response"),
Err(e) => panic!("HANDLE FAILED {:?}", e), Err(e) => panic!("HANDLE FAILED {:?}", e),
}; };
}, }
Event::Disconnected => { Event::Disconnected => {
log::info!("GOT A Event::Disconnected msg!"); log::info!("GOT A Event::Disconnected msg!");
} }
@@ -55,22 +80,27 @@ pub fn make_event_loop(mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>
} }
#[cfg(feature = "pingpong")] #[cfg(feature = "pingpong")]
pub fn make_event_loop(mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>, rx: mpsc::Receiver<Event>, do_log: bool) -> Result<()> { pub fn make_event_loop(
mut mqtt: EspMqttClient<ConnState<MessageImpl, EspError>>,
rx: mpsc::Receiver<Event>,
do_log: bool,
) -> Result<()> {
log::info!("About to subscribe to the mpsc channel"); log::info!("About to subscribe to the mpsc channel");
while let Ok(event) = rx.recv() { while let Ok(event) = rx.recv() {
match event { match event {
Event::Connected => { Event::Connected => {
log::info!("SUBSCRIBE TO {}", TOPIC); log::info!("SUBSCRIBE TO {}", TOPIC);
mqtt.subscribe(TOPIC, QOS).expect("could not MQTT subscribe"); mqtt.subscribe(TOPIC, QOS)
}, .expect("could not MQTT subscribe");
}
Event::Message(msg_bytes) => { Event::Message(msg_bytes) => {
let b = sphinx_key_signer::parse_ping_and_form_response(msg_bytes); let b = sphinx_key_signer::parse_ping_and_form_response(msg_bytes);
if do_log { if do_log {
log::info!("GOT A PING MESSAGE! returning pong now..."); log::info!("GOT A PING MESSAGE! returning pong now...");
} }
mqtt.publish(RETURN_TOPIC, QOS, false, b).expect("could not publish ping response"); mqtt.publish(RETURN_TOPIC, QOS, false, b)
}, .expect("could not publish ping response");
}
Event::Disconnected => { Event::Disconnected => {
log::info!("GOT A Event::Disconnected msg!"); log::info!("GOT A Event::Disconnected msg!");
} }