Remove wsts from stacks-signer

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

Cargo.lock

@@ -44,8 +44,6 @@ mod session;
 mod signer_set;
 /// v0 signer related code
 pub mod v0;
-/// v1 signer related code
-pub mod v1;
 
 use std::cmp::Eq;
 use std::fmt::Debug;

libsigner/src/libsigner.rs

@@ -41,20 +41,15 @@ const STDERR: i32 = 2;
 /// Trait describing the needful components of a top-level runloop.
 /// This is where the signer business logic would go.
 /// Implement this, and you get all the multithreaded setup for free.
-pub trait SignerRunLoop<R: Send, CMD: Send, T: SignerEventTrait> {
+pub trait SignerRunLoop<R: Send, T: SignerEventTrait> {
     /// Hint to set how long to wait for new events
     fn set_event_timeout(&mut self, timeout: Duration);
     /// Getter for the event poll timeout
     fn get_event_timeout(&self) -> Duration;
     /// Run one pass of the event loop, given new Signer events discovered since the last pass.
     /// Returns Some(R) if this is the final pass -- the runloop evaluated to R
     /// Returns None to keep running.
-    fn run_one_pass(
-        &mut self,
-        event: Option<SignerEvent<T>>,
-        cmd: Option<CMD>,
-        res: &Sender<R>,
-    ) -> Option<R>;
+    fn run_one_pass(&mut self, event: Option<SignerEvent<T>>, res: &Sender<R>) -> Option<R>;
 
     /// This is the main loop body for the signer. It continuously receives events from
     /// `event_recv`, polling for up to `self.get_event_timeout()` units of time.  Once it has
@@ -66,7 +61,6 @@ pub trait SignerRunLoop<R: Send, CMD: Send, T: SignerEventTrait> {
     fn main_loop<EVST: EventStopSignaler>(
         &mut self,
         event_recv: Receiver<SignerEvent<T>>,
-        command_recv: Receiver<CMD>,
         result_send: Sender<R>,
         mut event_stop_signaler: EVST,
     ) -> Option<R> {
@@ -81,11 +75,7 @@ pub trait SignerRunLoop<R: Send, CMD: Send, T: SignerEventTrait> {
                     return None;
                 }
             };
-            // Do not block for commands
-            let next_command_opt = command_recv.try_recv().ok();
-            if let Some(final_state) =
-                self.run_one_pass(next_event_opt, next_command_opt, &result_send)
-            {
+            if let Some(final_state) = self.run_one_pass(next_event_opt, &result_send) {
                 info!("Runloop exit; signaling event-receiver to stop");
                 event_stop_signaler.send();
                 return Some(final_state);
@@ -95,13 +85,11 @@ pub trait SignerRunLoop<R: Send, CMD: Send, T: SignerEventTrait> {
 }
 
 /// The top-level signer implementation
-pub struct Signer<CMD, R, SL, EV, T> {
+pub struct Signer<R, SL, EV, T> {
     /// the runloop itself
     signer_loop: Option<SL>,
     /// the event receiver to use
     event_receiver: Option<EV>,
-    /// the command receiver to use
-    command_receiver: Option<Receiver<CMD>>,
     /// the result sender to use
     result_sender: Option<Sender<R>>,
     /// phantom data for the codec
@@ -193,31 +181,24 @@ pub fn set_runloop_signal_handler<ST: EventStopSignaler + Send + 'static>(mut st
     }).expect("FATAL: failed to set signal handler");
 }
 
-impl<CMD, R, SL, EV, T> Signer<CMD, R, SL, EV, T> {
+impl<R, SL, EV, T> Signer<R, SL, EV, T> {
     /// Create a new signer with the given runloop and event receiver.
-    pub fn new(
-        runloop: SL,
-        event_receiver: EV,
-        command_receiver: Receiver<CMD>,
-        result_sender: Sender<R>,
-    ) -> Signer<CMD, R, SL, EV, T> {
+    pub fn new(runloop: SL, event_receiver: EV, result_sender: Sender<R>) -> Signer<R, SL, EV, T> {
         Signer {
             signer_loop: Some(runloop),
             event_receiver: Some(event_receiver),
-            command_receiver: Some(command_receiver),
             result_sender: Some(result_sender),
             phantom_data: PhantomData,
         }
     }
 }
 
 impl<
-        CMD: Send + 'static,
         R: Send + 'static,
         T: SignerEventTrait + 'static,
-        SL: SignerRunLoop<R, CMD, T> + Send + 'static,
+        SL: SignerRunLoop<R, T> + Send + 'static,
         EV: EventReceiver<T> + Send + 'static,
-    > Signer<CMD, R, SL, EV, T>
+    > Signer<R, SL, EV, T>
 {
     /// This is a helper function to spawn both the runloop and event receiver in their own
     /// threads.  Advanced signers may not need this method, and instead opt to run the receiver
@@ -234,10 +215,6 @@ impl<
             .event_receiver
             .take()
             .ok_or(EventError::AlreadyRunning)?;
-        let command_receiver = self
-            .command_receiver
-            .take()
-            .ok_or(EventError::AlreadyRunning)?;
         let result_sender = self
             .result_sender
             .take()
@@ -266,9 +243,7 @@ impl<
         let runloop_thread = thread::Builder::new()
             .name(format!("signer_runloop:{bind_port}"))
             .stack_size(THREAD_STACK_SIZE)
-            .spawn(move || {
-                signer_loop.main_loop(event_recv, command_receiver, result_sender, stop_signaler)
-            })
+            .spawn(move || signer_loop.main_loop(event_recv, result_sender, stop_signaler))
             .map_err(|e| {
                 error!("SignerRunLoop failed to start: {:?}", &e);
                 ret_stop_signaler.send();

libsigner/src/runloop.rs

@@ -25,7 +25,7 @@ use crate::http::{decode_http_body, decode_http_request, decode_http_response, r
 
 #[test]
 fn test_decode_http_request_ok() {
-    let tests = vec![
+    let tests = [
         ("GET /foo HTTP/1.1\r\nHost: localhost:6270\r\n\r\n",
         ("GET", "/foo", vec![("host", "localhost:6270")])),
         ("POST asdf HTTP/1.1\r\nHost: core.blockstack.org\r\nFoo: Bar\r\n\r\n",
@@ -61,7 +61,7 @@ fn test_decode_http_request_ok() {
 
 #[test]
 fn test_decode_http_request_err() {
-    let tests = vec![
+    let tests = [
         (
             "GET /foo HTTP/1.1\r\n",
             EventError::Deserialize("".to_string()),
@@ -99,7 +99,7 @@ fn test_decode_http_request_err() {
 
 #[test]
 fn test_decode_http_response_ok() {
-    let tests = vec![
+    let tests = [
         ("HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: 123\r\nX-Request-ID: 0\r\n\r\n",
         vec![("content-type", "application/octet-stream"), ("content-length", "123"), ("x-request-id", "0")]),
         ("HTTP/1.1 200 Ok\r\nContent-Type: application/octet-stream\r\nTransfer-encoding: chunked\r\nX-Request-ID: 0\r\n\r\n",
@@ -123,7 +123,7 @@ fn test_decode_http_response_ok() {
 
 #[test]
 fn test_decode_http_response_err() {
-    let tests = vec![
+    let tests = [
         ("HTTP/1.1 400 Bad Request\r\nContent-Type: application/json\r\nContent-Length: 456\r\nFoo: Bar\r\nX-Request-ID: 0\r\n\r\n",
          RPCError::HttpError(400)),
         ("HTTP/1.1 200",
@@ -223,7 +223,7 @@ impl Write for MockHTTPSocket {
 
 #[test]
 fn test_run_http_request_with_body() {
-    let tests = vec![
+    let tests = [
         ("GET", "/test-no-content-type-and-no-body", None, vec![]),
         (
             "GET",
@@ -288,7 +288,7 @@ fn test_run_http_request_with_body() {
 
 #[test]
 fn test_run_http_request_no_body() {
-    let tests = vec![
+    let tests = [
         ("GET", "/test-no-content-type-and-no-body", None, vec![]),
         (
             "GET",

libsigner/src/tests/http.rs

@@ -24,11 +24,16 @@ use std::time::Duration;
 use std::{mem, thread};
 
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
+use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::util_lib::boot::boot_code_id;
+use clarity::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
+use clarity::util::hash::Sha512Trunc256Sum;
+use clarity::util::secp256k1::MessageSignature;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::StackerDBChunkData;
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
     read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
     StacksMessageCodec,
@@ -38,8 +43,8 @@ use stacks_common::util::sleep_ms;
 use wsts::net::{DkgBegin, Packet};
 
 use crate::events::{SignerEvent, SignerEventTrait};
-use crate::v1::messages::SignerMessage;
-use crate::{Signer, SignerEventReceiver, SignerRunLoop};
+use crate::v0::messages::{BlockRejection, SignerMessage};
+use crate::{BlockProposal, Signer, SignerEventReceiver, SignerRunLoop};
 
 /// Simple runloop implementation.  It receives `max_events` events and returns `events` from the
 /// last call to `run_one_pass` as its final state.
@@ -63,7 +68,7 @@ enum Command {
     Empty,
 }
 
-impl<T: SignerEventTrait> SignerRunLoop<Vec<SignerEvent<T>>, Command, T> for SimpleRunLoop<T> {
+impl<T: SignerEventTrait> SignerRunLoop<Vec<SignerEvent<T>>, T> for SimpleRunLoop<T> {
     fn set_event_timeout(&mut self, timeout: Duration) {
         self.poll_timeout = timeout;
     }
@@ -75,7 +80,6 @@ impl<T: SignerEventTrait> SignerRunLoop<Vec<SignerEvent<T>>, Command, T> for Sim
     fn run_one_pass(
         &mut self,
         event: Option<SignerEvent<T>>,
-        _cmd: Option<Command>,
         _res: &Sender<Vec<SignerEvent<T>>>,
     ) -> Option<Vec<SignerEvent<T>>> {
         debug!("Got event: {:?}", &event);
@@ -99,16 +103,34 @@ impl<T: SignerEventTrait> SignerRunLoop<Vec<SignerEvent<T>>, Command, T> for Sim
 fn test_simple_signer() {
     let contract_id = NakamotoSigners::make_signers_db_contract_id(0, 0, false);
     let ev = SignerEventReceiver::new(false);
-    let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let max_events = 5;
-    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, cmd_recv, res_send);
+    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, res_send);
     let endpoint: SocketAddr = "127.0.0.1:30000".parse().unwrap();
     let mut chunks = vec![];
+    let block_proposal = BlockProposal {
+        block: NakamotoBlock {
+            header: NakamotoBlockHeader {
+                version: 1,
+                chain_length: 10,
+                burn_spent: 10,
+                consensus_hash: ConsensusHash([0; 20]),
+                parent_block_id: StacksBlockId([0; 32]),
+                tx_merkle_root: Sha512Trunc256Sum([0; 32]),
+                state_index_root: TrieHash([0; 32]),
+                timestamp: 11,
+                miner_signature: MessageSignature::empty(),
+                signer_signature: vec![],
+                pox_treatment: BitVec::ones(1).unwrap(),
+            },
+            txs: vec![],
+        },
+        burn_height: 2,
+        reward_cycle: 1,
+    };
     for i in 0..max_events {
         let privk = Secp256k1PrivateKey::new();
-        let msg = wsts::net::Message::DkgBegin(DkgBegin { dkg_id: 0 });
-        let message = SignerMessage::Packet(Packet { msg, sig: vec![] });
+        let message = SignerMessage::BlockProposal(block_proposal.clone());
         let message_bytes = message.serialize_to_vec();
         let mut chunk = StackerDBChunkData::new(i as u32, 1, message_bytes);
         chunk.sign(&privk).unwrap();
@@ -178,10 +200,9 @@ fn test_simple_signer() {
 #[test]
 fn test_status_endpoint() {
     let ev = SignerEventReceiver::new(false);
-    let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let max_events = 1;
-    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, cmd_recv, res_send);
+    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, res_send);
     let endpoint: SocketAddr = "127.0.0.1:31000".parse().unwrap();
 
     // simulate a node that's trying to push data