Merge pull request #5316 from stacks-network/update-clarity-wasm-develop

Update clarity wasm develop

Author: csgui

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
     - `get-tenure-info?` added
     - `get-block-info?` removed
 - Added `/v3/signer/{signer_pubkey}/{reward_cycle}` endpoint
+- Added optional `timeout_ms` to `events_observer` configuration
 
 ## [2.5.0.0.7]
 

stacks-common/src/libcommon.rs

@@ -86,7 +86,7 @@ pub mod consts {
 
     /// this should be updated to the latest network epoch version supported by
     ///  this node. this will be checked by the `validate_epochs()` method.
-    pub const PEER_NETWORK_EPOCH: u32 = PEER_VERSION_EPOCH_2_5 as u32;
+    pub const PEER_NETWORK_EPOCH: u32 = PEER_VERSION_EPOCH_3_0 as u32;
 
     /// set the fourth byte of the peer version
     pub const PEER_VERSION_MAINNET: u32 = PEER_VERSION_MAINNET_MAJOR | PEER_NETWORK_EPOCH;

stacks-signer/src/client/stackerdb.rs

@@ -255,6 +255,7 @@ mod tests {
             Some(100_000),
             None,
             Some(9000),
+            None,
         );
         let config = GlobalConfig::load_from_str(&signer_config[0]).unwrap();
         let signer_config = generate_signer_config(&config, 5);

stacks-signer/src/client/stacks_client.rs

@@ -45,7 +45,7 @@ use serde::Deserialize;
 use serde_json::json;
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
-use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
+use stacks_common::consts::CHAIN_ID_MAINNET;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
@@ -99,7 +99,7 @@ impl From<&GlobalConfig> for StacksClient {
             stacks_address: config.stacks_address,
             http_origin: format!("http://{}", config.node_host),
             tx_version: config.network.to_transaction_version(),
-            chain_id: config.network.to_chain_id(),
+            chain_id: config.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
             mainnet: config.network.is_mainnet(),
             auth_password: config.auth_password.clone(),
@@ -114,18 +114,14 @@ impl StacksClient {
         node_host: String,
         auth_password: String,
         mainnet: bool,
+        chain_id: u32,
     ) -> Self {
         let pubkey = StacksPublicKey::from_private(&stacks_private_key);
         let tx_version = if mainnet {
             TransactionVersion::Mainnet
         } else {
             TransactionVersion::Testnet
         };
-        let chain_id = if mainnet {
-            CHAIN_ID_MAINNET
-        } else {
-            CHAIN_ID_TESTNET
-        };
         let stacks_address = StacksAddress::p2pkh(mainnet, &pubkey);
         Self {
             stacks_private_key,
@@ -145,7 +141,13 @@ impl StacksClient {
         node_host: String,
         auth_password: String,
     ) -> Result<Self, ClientError> {
-        let mut stacks_client = Self::new(stacks_private_key, node_host, auth_password, true);
+        let mut stacks_client = Self::new(
+            stacks_private_key,
+            node_host,
+            auth_password,
+            true,
+            CHAIN_ID_MAINNET,
+        );
         let pubkey = StacksPublicKey::from_private(&stacks_private_key);
         let info = stacks_client.get_peer_info()?;
         if info.network_id == CHAIN_ID_MAINNET {
@@ -154,7 +156,7 @@ impl StacksClient {
             stacks_client.tx_version = TransactionVersion::Mainnet;
         } else {
             stacks_client.mainnet = false;
-            stacks_client.chain_id = CHAIN_ID_TESTNET;
+            stacks_client.chain_id = info.network_id;
             stacks_client.tx_version = TransactionVersion::Testnet;
         }
         stacks_client.stacks_address = StacksAddress::p2pkh(stacks_client.mainnet, &pubkey);
@@ -1219,4 +1221,12 @@ mod tests {
         write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), reward_cycle as u128);
     }
+
+    #[test]
+    fn get_chain_id_from_config() {
+        let mock = MockServerClient::from_config(
+            GlobalConfig::load_from_file("./src/tests/conf/signer-custom-chain-id.toml").unwrap(),
+        );
+        assert_eq!(mock.client.chain_id, 0x80000100);
+    }
 }

stacks-signer/src/config.rs

@@ -76,14 +76,6 @@ impl std::fmt::Display for Network {
 }
 
 impl Network {
-    /// Converts a Network enum variant to a corresponding chain id
-    pub const fn to_chain_id(&self) -> u32 {
-        match self {
-            Self::Mainnet => CHAIN_ID_MAINNET,
-            Self::Testnet | Self::Mocknet => CHAIN_ID_TESTNET,
-        }
-    }
-
     /// Convert a Network enum variant to a corresponding address version
     pub const fn to_address_version(&self) -> u8 {
         match self {
@@ -163,6 +155,8 @@ pub struct GlobalConfig {
     pub first_proposal_burn_block_timing: Duration,
     /// How much time to wait for a miner to propose a block following a sortition
     pub block_proposal_timeout: Duration,
+    /// An optional custom Chain ID
+    chain_id: Option<u32>,
 }
 
 /// Internal struct for loading up the config file
@@ -190,6 +184,8 @@ struct RawConfigFile {
     pub first_proposal_burn_block_timing_secs: Option<u64>,
     /// How much time to wait for a miner to propose a block following a sortition in milliseconds
     pub block_proposal_timeout_ms: Option<u64>,
+    /// An optional custom Chain ID
+    pub chain_id: Option<u32>,
 }
 
 impl RawConfigFile {
@@ -278,6 +274,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             metrics_endpoint,
             first_proposal_burn_block_timing,
             block_proposal_timeout,
+            chain_id: raw_data.chain_id,
         })
     }
 }
@@ -308,13 +305,15 @@ impl GlobalConfig {
             Some(endpoint) => endpoint.to_string(),
             None => "None".to_string(),
         };
+        let chain_id = format!("{:x}", self.to_chain_id());
         format!(
             r#"
 Stacks node host: {node_host}
 Signer endpoint: {endpoint}
 Stacks address: {stacks_address}
 Public key: {public_key}
 Network: {network}
+Chain ID: 0x{chain_id}
 Database path: {db_path}
 Metrics endpoint: {metrics_endpoint}
 "#,
@@ -329,6 +328,14 @@ Metrics endpoint: {metrics_endpoint}
             metrics_endpoint = metrics_endpoint,
         )
     }
+
+    /// Get the chain ID for the network
+    pub fn to_chain_id(&self) -> u32 {
+        self.chain_id.unwrap_or_else(|| match self.network {
+            Network::Mainnet => CHAIN_ID_MAINNET,
+            Network::Testnet | Network::Mocknet => CHAIN_ID_TESTNET,
+        })
+    }
 }
 
 impl Display for GlobalConfig {
@@ -356,6 +363,7 @@ pub fn build_signer_config_tomls(
     max_tx_fee_ustx: Option<u64>,
     tx_fee_ustx: Option<u64>,
     mut metrics_port_start: Option<usize>,
+    chain_id: Option<u32>,
 ) -> Vec<String> {
     let mut signer_config_tomls = vec![];
 
@@ -421,6 +429,15 @@ metrics_endpoint = "{metrics_endpoint}"
             metrics_port_start = Some(metrics_port + 1);
         }
 
+        if let Some(chain_id) = chain_id {
+            signer_config_toml = format!(
+                r#"
+{signer_config_toml}
+chain_id = {chain_id}
+"#
+            )
+        }
+
         signer_config_tomls.push(signer_config_toml);
     }
 
@@ -453,13 +470,16 @@ mod tests {
             None,
             None,
             Some(4000),
+            None,
         );
 
         let config =
             RawConfigFile::load_from_str(&config_tomls[0]).expect("Failed to parse config file");
 
         assert_eq!(config.auth_password, "melon");
         assert_eq!(config.metrics_endpoint, Some("localhost:4000".to_string()));
+        let global_config = GlobalConfig::try_from(config).unwrap();
+        assert_eq!(global_config.to_chain_id(), CHAIN_ID_TESTNET);
     }
 
     #[test]
@@ -473,8 +493,10 @@ Signer endpoint: 127.0.0.1:30000
 Stacks address: ST3FPN8KBZ3YPBP0ZJGAAHTVFMQDTJCR5QPS7VTNJ
 Public key: 03bc489f27da3701d9f9e577c88de5567cf4023111b7577042d55cde4d823a3505
 Network: testnet
+Chain ID: 0x80000000
 Database path: :memory:
 Metrics endpoint: 0.0.0.0:9090
+Chain ID: 2147483648
 "#;
 
         let expected_str_v6 = r#"
@@ -483,6 +505,7 @@ Signer endpoint: [::1]:30000
 Stacks address: ST3FPN8KBZ3YPBP0ZJGAAHTVFMQDTJCR5QPS7VTNJ
 Public key: 03bc489f27da3701d9f9e577c88de5567cf4023111b7577042d55cde4d823a3505
 Network: testnet
+Chain ID: 0x80000000
 Database path: :memory:
 Metrics endpoint: 0.0.0.0:9090
 "#;
@@ -531,5 +554,37 @@ db_path = ":memory:"
         );
         let config = GlobalConfig::load_from_str(&config_toml).unwrap();
         assert_eq!(config.stacks_address.to_string(), expected_addr);
+        assert_eq!(config.to_chain_id(), CHAIN_ID_MAINNET);
+    }
+
+    #[test]
+    fn test_custom_chain_id() {
+        let pk = StacksPrivateKey::from_hex(
+            "eb05c83546fdd2c79f10f5ad5434a90dd28f7e3acb7c092157aa1bc3656b012c01",
+        )
+        .unwrap();
+
+        let node_host = "localhost";
+        let network = Network::Testnet;
+        let password = "melon";
+        let config_tomls = build_signer_config_tomls(
+            &[pk],
+            node_host,
+            None,
+            &network,
+            password,
+            rand::random(),
+            3000,
+            None,
+            None,
+            Some(4000),
+            Some(0x80000100),
+        );
+
+        let config =
+            RawConfigFile::load_from_str(&config_tomls[0]).expect("Failed to parse config file");
+        assert_eq!(config.chain_id, Some(0x80000100));
+        let global_config = GlobalConfig::try_from(config).unwrap();
+        assert_eq!(global_config.to_chain_id(), 0x80000100);
     }
 }

stacks-signer/src/main.rs

@@ -121,7 +121,7 @@ fn handle_generate_stacking_signature(
         &private_key, //
         args.reward_cycle.into(),
         args.method.topic(),
-        config.network.to_chain_id(),
+        config.to_chain_id(),
         args.period.into(),
         args.max_amount,
         args.auth_id,

stacks-signer/src/tests/chainstate.rs

@@ -32,6 +32,7 @@ use clarity::util::vrf::VRFProof;
 use libsigner::BlockProposal;
 use slog::slog_info;
 use stacks_common::bitvec::BitVec;
+use stacks_common::consts::CHAIN_ID_TESTNET;
 use stacks_common::info;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksBlockId, StacksPrivateKey, StacksPublicKey, TrieHash,
@@ -96,6 +97,7 @@ fn setup_test_environment(
         SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 10000).to_string(),
         "FOO".into(),
         false,
+        CHAIN_ID_TESTNET,
     );
 
     let signer_db_dir = "/tmp/stacks-node-tests/signer-units/";

stacks-signer/src/tests/conf/signer-custom-chain-id.toml

@@ -0,0 +1,7 @@
+stacks_private_key = "126e916e77359ccf521e168feea1fcb9626c59dc375cae00c7464303381c7dff01"
+node_host = "127.0.0.1:20444"
+endpoint = "localhost:30001"
+network = "testnet"
+auth_password = "12345"
+db_path = ":memory:"
+chain_id = 0x80000100

stackslib/src/chainstate/nakamoto/mod.rs

@@ -3810,6 +3810,15 @@ impl NakamotoChainState {
         active_reward_set: &RewardSet,
     ) -> Result<(), ChainstateError> {
         if !tenure_block_commit.treatment.is_empty() {
+            let address_to_indeces: HashMap<_, Vec<_>> = active_reward_set
+                .rewarded_addresses
+                .iter()
+                .enumerate()
+                .fold(HashMap::new(), |mut map, (ix, addr)| {
+                    map.entry(addr).or_insert_with(Vec::new).push(ix);
+                    map
+                });
+
             // our block commit issued a punishment, check the reward set and bitvector
             //  to ensure that this was valid.
             for treated_addr in tenure_block_commit.treatment.iter() {
@@ -3820,24 +3829,19 @@ impl NakamotoChainState {
                 }
                 // otherwise, we need to find the indices in the rewarded_addresses
                 //  corresponding to this address.
-                let address_indices = active_reward_set
-                    .rewarded_addresses
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(ix, addr)| {
-                        if addr == treated_addr.deref() {
-                            Some(ix)
-                        } else {
-                            None
-                        }
-                    });
+                let empty_vec = vec![];
+                let address_indices = address_to_indeces
+                    .get(treated_addr.deref())
+                    .unwrap_or(&empty_vec);
+
                 // if any of them are 0, punishment is okay.
                 // if all of them are 1, punishment is not okay.
                 // if all of them are 0, *must* have punished
                 let bitvec_values: Result<Vec<_>, ChainstateError> = address_indices
+                    .iter()
                     .map(
                         |ix| {
-                            let ix = u16::try_from(ix)
+                            let ix = u16::try_from(*ix)
                                 .map_err(|_| ChainstateError::InvalidStacksBlock("Reward set index outside of u16".into()))?;
                             let bitvec_value = block_bitvec.get(ix)
                                 .unwrap_or_else(|| {

stackslib/src/net/download/nakamoto/tenure.rs

@@ -325,15 +325,12 @@ impl TenureStartEnd {
                 wt_start.winning_block_id.clone(),
                 wt_end.winning_block_id.clone(),
                 rc,
-                downloader_block_height_to_reward_cycle(
-                    pox_constants,
-                    first_burn_height,
-                    wt_start.burn_height,
-                )
-                .expect(&format!(
-                    "FATAL: tenure from before system start ({} <= {})",
-                    wt_start.burn_height, first_burn_height
-                )),
+                pox_constants
+                    .block_height_to_reward_cycle(first_burn_height, wt_start.burn_height)
+                    .expect(&format!(
+                        "FATAL: tenure from before system start ({} <= {})",
+                        wt_start.burn_height, first_burn_height
+                    )),
                 wt.processed,
             );
             tenure_start_end.fetch_end_block = true;