Remove wsts from testnet/stacks-node

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

Author: jferrant

Cargo.lock

@@ -13,125 +13,77 @@
 // 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 std::collections::{BTreeMap, HashMap};
+
 use blockstack_lib::chainstate::stacks::boot::NakamotoSignerEntry;
-use hashbrown::{HashMap, HashSet};
 use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
-use wsts::curve::ecdsa;
-use wsts::curve::point::{Compressed, Point};
-use wsts::state_machine::PublicKeys;
 
-/// A reward set parsed into the structures required by WSTS party members and coordinators.
+/// A reward set parsed into relevant structures
 #[derive(Debug, Clone)]
 pub struct SignerEntries {
-    /// The signer addresses mapped to signer id
-    pub signer_ids: HashMap<StacksAddress, u32>,
-    /// The signer ids mapped to public key and key ids mapped to public keys
-    pub public_keys: PublicKeys,
-    /// The signer ids mapped to key ids
-    pub signer_key_ids: HashMap<u32, Vec<u32>>,
-    /// The signer ids mapped to wsts public keys
-    pub signer_public_keys: HashMap<u32, Point>,
-    /// The signer ids mapped to a hash set of key ids
-    /// The wsts coordinator uses a hash set for each signer since it needs to do lots of lookups
-    pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
+    /// The signer addresses mapped to signer ID
+    pub signer_addr_to_id: HashMap<StacksAddress, u32>,
+    /// The signer IDs mapped to addresses. Uses a BTreeMap to ensure *reward cycle order*
+    pub signer_id_to_addr: BTreeMap<u32, StacksAddress>,
+    /// signer ID mapped to public key
+    pub signer_id_to_pk: HashMap<u32, StacksPublicKey>,
+    /// public_key mapped to signer ID
+    pub signer_pk_to_id: HashMap<StacksPublicKey, u32>,
+    /// The signer public keys
+    pub signer_pks: Vec<StacksPublicKey>,
+    /// The signer addresses
+    pub signer_addresses: Vec<StacksAddress>,
+    /// The signer address mapped to signing weight
+    pub signer_addr_to_weight: HashMap<StacksAddress, u32>,
 }
 
 /// Parsing errors for `SignerEntries`
 #[derive(Debug)]
 pub enum Error {
     /// A member of the signing set has a signing key buffer
-    ///  which does not represent a ecdsa public key.
+    ///  which does not represent a valid Stacks public key
     BadSignerPublicKey(String),
     /// The number of signers was greater than u32::MAX
     SignerCountOverflow,
 }
 
 impl SignerEntries {
-    /// Try to parse the reward set defined by `NakamotoSignEntry` into the structures required
-    ///  by WSTS party members and coordinators.
+    /// Try to parse the reward set defined by `NakamotoSignEntry` into the SignerEntries struct
     pub fn parse(is_mainnet: bool, reward_set: &[NakamotoSignerEntry]) -> Result<Self, Error> {
-        let mut weight_end = 1;
-        let mut signer_key_ids = HashMap::with_capacity(reward_set.len());
-        let mut signer_public_keys = HashMap::with_capacity(reward_set.len());
-        let mut coordinator_key_ids = HashMap::with_capacity(4000);
-        let mut signer_ids = HashMap::with_capacity(reward_set.len());
-        let mut wsts_signers = HashMap::new();
-        let mut wsts_key_ids = HashMap::new();
+        let mut signer_pk_to_id = HashMap::with_capacity(reward_set.len());
+        let mut signer_id_to_pk = HashMap::with_capacity(reward_set.len());
+        let mut signer_addr_to_id = HashMap::with_capacity(reward_set.len());
+        let mut signer_pks = Vec::with_capacity(reward_set.len());
+        let mut signer_id_to_addr = BTreeMap::new();
+        let mut signer_addr_to_weight = HashMap::new();
+        let mut signer_addresses = Vec::with_capacity(reward_set.len());
         for (i, entry) in reward_set.iter().enumerate() {
             let signer_id = u32::try_from(i).map_err(|_| Error::SignerCountOverflow)?;
-            let ecdsa_pk =
-                ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
-                    Error::BadSignerPublicKey(format!(
-                        "Failed to convert signing key to ecdsa::PublicKey: {e}"
-                    ))
-                })?;
-            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_pk.to_bytes()))
-                .map_err(|e| {
-                    Error::BadSignerPublicKey(format!(
-                        "Failed to convert signing key to wsts::Point: {e}"
-                    ))
-                })?;
-            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice())
+            let signer_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice())
                 .map_err(|e| {
                     Error::BadSignerPublicKey(format!(
                         "Failed to convert signing key to StacksPublicKey: {e}"
                     ))
                 })?;
 
-            let stacks_address = StacksAddress::p2pkh(is_mainnet, &stacks_public_key);
-            signer_ids.insert(stacks_address, signer_id);
-
-            signer_public_keys.insert(signer_id, signer_public_key);
-            let weight_start = weight_end;
-            weight_end = weight_start + entry.weight;
-            let key_ids: HashSet<u32> = (weight_start..weight_end).collect();
-            for key_id in key_ids.iter() {
-                wsts_key_ids.insert(*key_id, ecdsa_pk);
-            }
-            signer_key_ids.insert(signer_id, (weight_start..weight_end).collect());
-            coordinator_key_ids.insert(signer_id, key_ids);
-            wsts_signers.insert(signer_id, ecdsa_pk);
+            let stacks_address = StacksAddress::p2pkh(is_mainnet, &signer_public_key);
+            signer_addr_to_id.insert(stacks_address, signer_id);
+            signer_id_to_pk.insert(signer_id, signer_public_key);
+            signer_pk_to_id.insert(signer_public_key, signer_id);
+            signer_pks.push(signer_public_key);
+            signer_id_to_addr.insert(signer_id, stacks_address);
+            signer_addr_to_weight.insert(stacks_address, entry.weight);
+            signer_addresses.push(stacks_address);
         }
 
         Ok(Self {
-            signer_ids,
-            public_keys: PublicKeys {
-                signers: wsts_signers,
-                key_ids: wsts_key_ids,
-            },
-            signer_key_ids,
-            signer_public_keys,
-            coordinator_key_ids,
+            signer_addr_to_id,
+            signer_id_to_pk,
+            signer_pk_to_id,
+            signer_pks,
+            signer_id_to_addr,
+            signer_addr_to_weight,
+            signer_addresses,
         })
     }
-
-    /// Return the number of Key IDs in the WSTS group signature
-    pub fn count_keys(&self) -> Result<u32, Error> {
-        self.public_keys
-            .key_ids
-            .len()
-            .try_into()
-            .map_err(|_| Error::SignerCountOverflow)
-    }
-
-    /// Return the number of Key IDs in the WSTS group signature
-    pub fn count_signers(&self) -> Result<u32, Error> {
-        self.public_keys
-            .signers
-            .len()
-            .try_into()
-            .map_err(|_| Error::SignerCountOverflow)
-    }
-
-    /// Return the number of Key IDs required to sign a message with the WSTS group signature
-    pub fn get_signing_threshold(&self) -> Result<u32, Error> {
-        let num_keys = self.count_keys()?;
-        Ok((num_keys as f64 * 7_f64 / 10_f64).ceil() as u32)
-    }
-
-    /// Return the number of Key IDs required to sign a message with the WSTS group signature
-    pub fn get_dkg_threshold(&self) -> Result<u32, Error> {
-        let num_keys = self.count_keys()?;
-        Ok((num_keys as f64 * 9_f64 / 10_f64).ceil() as u32)
-    }
 }

libsigner/src/signer_set.rs

@@ -123,6 +123,7 @@ where
 
 #[cfg(test)]
 pub(crate) mod tests {
+    use std::collections::{BTreeMap, HashMap};
     use std::io::{Read, Write};
     use std::net::{SocketAddr, TcpListener};
 
@@ -138,20 +139,16 @@ pub(crate) mod tests {
     use clarity::vm::costs::ExecutionCost;
     use clarity::vm::types::TupleData;
     use clarity::vm::Value as ClarityValue;
-    use hashbrown::{HashMap, HashSet};
     use libsigner::SignerEntries;
     use rand::distributions::Standard;
     use rand::{thread_rng, Rng};
-    use rand_core::{OsRng, RngCore};
+    use rand_core::RngCore;
     use stacks_common::types::chainstate::{
         BlockHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
     };
     use stacks_common::types::{StacksEpochId, StacksPublicKeyBuffer};
     use stacks_common::util::hash::{Hash160, Sha256Sum};
-    use wsts::curve::ecdsa;
-    use wsts::curve::point::{Compressed, Point};
-    use wsts::curve::scalar::Scalar;
-    use wsts::state_machine::PublicKeys;
+    use wsts::curve::point::Point;
 
     use super::*;
     use crate::config::{GlobalConfig, SignerConfig};
@@ -456,112 +453,59 @@ pub(crate) mod tests {
 
     /// Generate a signer config with the given number of signers and keys where the first signer is
     /// obtained from the provided global config
-    pub fn generate_signer_config(
-        config: &GlobalConfig,
-        num_signers: u32,
-        num_keys: u32,
-    ) -> SignerConfig {
+    pub fn generate_signer_config(config: &GlobalConfig, num_signers: u32) -> SignerConfig {
         assert!(
             num_signers > 0,
             "Cannot generate 0 signers...Specify at least 1 signer."
         );
-        assert!(
-            num_keys > 0,
-            "Cannot generate 0 keys for the provided signers...Specify at least 1 key."
-        );
-        let mut public_keys = PublicKeys {
-            signers: HashMap::new(),
-            key_ids: HashMap::new(),
-        };
+
+        let weight_per_signer = 100 / num_signers;
+        let mut remaining_weight = 100 % num_signers;
+
         let reward_cycle = thread_rng().next_u64();
-        let rng = &mut OsRng;
-        let num_keys = num_keys / num_signers;
-        let remaining_keys = num_keys % num_signers;
-        let mut coordinator_key_ids = HashMap::new();
-        let mut signer_key_ids = HashMap::new();
-        let mut signer_ids = HashMap::new();
-        let mut start_key_id = 1u32;
-        let mut end_key_id = start_key_id;
-        let mut signer_public_keys = HashMap::new();
-        let mut signer_slot_ids = vec![];
-        let ecdsa_private_key = config.ecdsa_private_key;
-        let ecdsa_public_key =
-            ecdsa::PublicKey::new(&ecdsa_private_key).expect("Failed to create ecdsa public key");
-        // Key ids start from 1 hence the wrapping adds everywhere
+
+        let mut signer_pk_to_id = HashMap::new();
+        let mut signer_id_to_pk = HashMap::new();
+        let mut signer_addr_to_id = HashMap::new();
+        let mut signer_pks = Vec::new();
+        let mut signer_slot_ids = Vec::new();
+        let mut signer_id_to_addr = BTreeMap::new();
+        let mut signer_addr_to_weight = HashMap::new();
+        let mut signer_addresses = Vec::new();
+
         for signer_id in 0..num_signers {
-            end_key_id = if signer_id.wrapping_add(1) == num_signers {
-                end_key_id.wrapping_add(remaining_keys)
+            let private_key = if signer_id == 0 {
+                config.stacks_private_key
             } else {
-                end_key_id.wrapping_add(num_keys)
+                StacksPrivateKey::new()
             };
-            if signer_id == 0 {
-                public_keys.signers.insert(signer_id, ecdsa_public_key);
-                let signer_public_key =
-                    Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes())).unwrap();
-                signer_public_keys.insert(signer_id, signer_public_key);
-                public_keys.signers.insert(signer_id, ecdsa_public_key);
-                for k in start_key_id..end_key_id {
-                    public_keys.key_ids.insert(k, ecdsa_public_key);
-                    coordinator_key_ids
-                        .entry(signer_id)
-                        .or_insert(HashSet::new())
-                        .insert(k);
-                    signer_key_ids
-                        .entry(signer_id)
-                        .or_insert(Vec::new())
-                        .push(k);
-                }
-                start_key_id = end_key_id;
-                let address = StacksAddress::p2pkh(
-                    false,
-                    &StacksPublicKey::from_slice(ecdsa_public_key.to_bytes().as_slice())
-                        .expect("Failed to create stacks public key"),
-                );
-                signer_slot_ids.push(SignerSlotID(signer_id));
-                signer_ids.insert(address, signer_id);
-
-                continue;
-            }
-            let private_key = Scalar::random(rng);
-            let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
-            let signer_public_key =
-                Point::try_from(&Compressed::from(public_key.to_bytes())).unwrap();
-            signer_public_keys.insert(signer_id, signer_public_key);
-            public_keys.signers.insert(signer_id, public_key);
-            for k in start_key_id..end_key_id {
-                public_keys.key_ids.insert(k, public_key);
-                coordinator_key_ids
-                    .entry(signer_id)
-                    .or_insert(HashSet::new())
-                    .insert(k);
-                signer_key_ids
-                    .entry(signer_id)
-                    .or_insert(Vec::new())
-                    .push(k);
-            }
-            let address = StacksAddress::p2pkh(
-                false,
-                &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
-                    .expect("Failed to create stacks public key"),
-            );
+            let public_key = StacksPublicKey::from_private(&private_key);
+
+            signer_id_to_pk.insert(signer_id, public_key);
+            signer_pk_to_id.insert(public_key, signer_id);
+            let address = StacksAddress::p2pkh(false, &public_key);
+            signer_addr_to_id.insert(address, signer_id);
+            signer_pks.push(public_key);
             signer_slot_ids.push(SignerSlotID(signer_id));
-            signer_ids.insert(address, signer_id);
-            start_key_id = end_key_id;
+            signer_id_to_addr.insert(signer_id, address);
+            signer_addr_to_weight.insert(address, weight_per_signer + remaining_weight);
+            signer_addresses.push(address);
+            remaining_weight = 0; // The first signer gets the extra weight if there is any. All other signers only get the weight_per_signer
         }
         SignerConfig {
             reward_cycle,
             signer_id: 0,
             signer_slot_id: SignerSlotID(rand::thread_rng().gen_range(0..num_signers)), // Give a random signer slot id between 0 and num_signers
-            key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
             signer_entries: SignerEntries {
-                public_keys,
-                coordinator_key_ids,
-                signer_key_ids,
-                signer_ids,
-                signer_public_keys,
+                signer_addr_to_id,
+                signer_id_to_pk,
+                signer_pk_to_id,
+                signer_pks,
+                signer_id_to_addr,
+                signer_addr_to_weight,
+                signer_addresses,
             },
             signer_slot_ids,
-            ecdsa_private_key: config.ecdsa_private_key,
             stacks_private_key: config.stacks_private_key,
             node_host: config.node_host.to_string(),
             mainnet: config.network.is_mainnet(),

stacks-signer/src/client/mod.rs

@@ -257,7 +257,7 @@ mod tests {
             Some(9000),
         );
         let config = GlobalConfig::load_from_str(&signer_config[0]).unwrap();
-        let signer_config = generate_signer_config(&config, 5, 20);
+        let signer_config = generate_signer_config(&config, 5);
         let mut stackerdb = StackerDB::from(&signer_config);
 
         let header = NakamotoBlockHeader::empty();