Merge branch 'next' into feat/ci-build-docker-signer

Author: wileyj

Cargo.lock

@@ -79,14 +79,8 @@ pub trait SignerRunLoop<R: Send, CMD: Send> {
                     return None;
                 }
             };
-            let next_command_opt = match command_recv.recv_timeout(poll_timeout) {
-                Ok(cmd) => Some(cmd),
-                Err(RecvTimeoutError::Timeout) => None,
-                Err(RecvTimeoutError::Disconnected) => {
-                    info!("Command receiver disconnected");
-                    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.clone())
             {

libsigner/src/runloop.rs

@@ -13,7 +13,6 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::net::api::postblock_proposal::{BlockValidateReject, ValidateRejectCode};
 use clarity::vm::types::QualifiedContractIdentifier;
@@ -78,6 +77,17 @@ pub struct BlockRejection {
     pub block: NakamotoBlock,
 }
 
+impl BlockRejection {
+    /// Create a new BlockRejection for the provided block and reason code
+    pub fn new(block: NakamotoBlock, reason_code: RejectCode) -> Self {
+        Self {
+            reason: reason_code.to_string(),
+            reason_code,
+            block,
+        }
+    }
+}
+
 impl From<BlockValidateReject> for BlockRejection {
     fn from(reject: BlockValidateReject) -> Self {
         Self {
@@ -94,8 +104,22 @@ impl From<BlockValidateReject> for BlockRejection {
 pub enum RejectCode {
     /// RPC endpoint Validation failed
     ValidationFailed(ValidateRejectCode),
-    /// Missing expected transactions
-    MissingTransactions(Vec<Txid>),
+    /// Signers signed a block rejection
+    SignedRejection,
+    /// Invalid signature hash
+    InvalidSignatureHash,
+}
+
+impl std::fmt::Display for RejectCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
+            RejectCode::SignedRejection => {
+                write!(f, "A threshold number of signers rejected the block.")
+            }
+            RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
+        }
+    }
 }
 
 impl From<Packet> for SignerMessage {
@@ -116,6 +140,12 @@ impl From<BlockRejection> for SignerMessage {
     }
 }
 
+impl From<BlockValidateReject> for SignerMessage {
+    fn from(rejection: BlockValidateReject) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
+    }
+}
+
 impl SignerMessage {
     /// Helper function to determine the slot ID for the provided stacker-db writer id
     pub fn slot_id(&self, id: u32) -> u32 {

stacks-signer/src/client/stackerdb.rs

@@ -36,7 +36,7 @@ use wsts::state_machine::PublicKeys;
 /// List of key_ids for each signer_id
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
 
-const EVENT_TIMEOUT_MS: u64 = 50;
+const EVENT_TIMEOUT_MS: u64 = 5000;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration

stacks-signer/src/config.rs

@@ -33,16 +33,18 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession};
 use libstackerdb::StackerDBChunkData;
-use slog::slog_debug;
+use slog::{slog_debug, slog_error};
 use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
-use stacks_common::debug;
+use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::{debug, error};
 use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
@@ -204,10 +206,15 @@ fn handle_dkg(args: RunDkgArgs) {
 fn handle_sign(args: SignArgs) {
     debug!("Signing message...");
     let spawned_signer = spawn_running_signer(&args.config);
+    let Some(block) = read_next::<NakamotoBlock, _>(&mut &args.data[..]).ok() else {
+        error!("Unable to parse provided message as a NakamotoBlock.");
+        spawned_signer.running_signer.stop();
+        return;
+    };
     spawned_signer
         .cmd_send
         .send(RunLoopCommand::Sign {
-            message: args.data,
+            block,
             is_taproot: false,
             merkle_root: None,
         })
@@ -220,12 +227,17 @@ fn handle_sign(args: SignArgs) {
 fn handle_dkg_sign(args: SignArgs) {
     debug!("Running DKG and signing message...");
     let spawned_signer = spawn_running_signer(&args.config);
+    let Some(block) = read_next::<NakamotoBlock, _>(&mut &args.data[..]).ok() else {
+        error!("Unable to parse provided message as a NakamotoBlock.");
+        spawned_signer.running_signer.stop();
+        return;
+    };
     // First execute DKG, then sign
     spawned_signer.cmd_send.send(RunLoopCommand::Dkg).unwrap();
     spawned_signer
         .cmd_send
         .send(RunLoopCommand::Sign {
-            message: args.data,
+            block,
             is_taproot: false,
             merkle_root: None,
         })