Merge branch 'develop' into feat/recover-events

Author: obycode

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/blockstack_cli.rs

@@ -73,7 +73,9 @@ For usage information on those methods, call `blockstack-cli [method] -h`
 
 `blockstack-cli` accepts flag options as well:
 
-   --testnet       instruct the transaction generator to use a testnet version byte instead of MAINNET (default)
+   --testnet[=chain-id]
+                     instruct the transaction generator to use a testnet version byte instead of MAINNET (default)
+                     optionally, you can specify a custom chain ID to use for the transaction
 
 ";
 
@@ -185,6 +187,7 @@ enum CliError {
     ClarityGeneralError(ClarityError),
     Message(String),
     Usage,
+    InvalidChainId(std::num::ParseIntError),
 }
 
 impl std::error::Error for CliError {
@@ -204,6 +207,7 @@ impl std::fmt::Display for CliError {
             CliError::ClarityGeneralError(e) => write!(f, "Clarity error: {}", e),
             CliError::Message(e) => write!(f, "{}", e),
             CliError::Usage => write!(f, "{}", USAGE),
+            CliError::InvalidChainId(e) => write!(f, "Invalid chain ID: {}", e),
         }
     }
 }
@@ -848,18 +852,26 @@ fn main() {
 }
 
 fn main_handler(mut argv: Vec<String>) -> Result<String, CliError> {
-    let tx_version = if let Some(ix) = argv.iter().position(|x| x == "--testnet") {
-        argv.remove(ix);
-        TransactionVersion::Testnet
-    } else {
-        TransactionVersion::Mainnet
-    };
+    let mut tx_version = TransactionVersion::Mainnet;
+    let mut chain_id = CHAIN_ID_MAINNET;
+
+    // Look for the `--testnet` flag
+    if let Some(ix) = argv.iter().position(|x| x.starts_with("--testnet")) {
+        let flag = argv.remove(ix);
+
+        // Check if `--testnet=<chain_id>` is used
+        if let Some(custom_chain_id) = flag.split('=').nth(1) {
+            // Attempt to parse the custom chain ID from hex
+            chain_id = u32::from_str_radix(custom_chain_id.trim_start_matches("0x"), 16)
+                .map_err(|err| CliError::InvalidChainId(err))?;
+        } else {
+            // Use the default testnet chain ID
+            chain_id = CHAIN_ID_TESTNET;
+        }
 
-    let chain_id = if tx_version == TransactionVersion::Testnet {
-        CHAIN_ID_TESTNET
-    } else {
-        CHAIN_ID_MAINNET
-    };
+        // Set the transaction version to Testnet
+        tx_version = TransactionVersion::Testnet;
+    }
 
     if let Some((method, args)) = argv.split_first() {
         match method.as_str() {
@@ -1220,4 +1232,43 @@ mod test {
         let result = main_handler(to_string_vec(&header_args)).unwrap();
         eprintln!("result:\n{}", result);
     }
+
+    #[test]
+    fn custom_chain_id() {
+        // Standard chain id
+        let tt_args = [
+            "--testnet",
+            "token-transfer",
+            "043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3",
+            "1",
+            "0",
+            "ST1A14RBKJ289E3DP89QAZE2RRHDPWP5RHMYFRCHV",
+            "10",
+        ];
+
+        let result = main_handler(to_string_vec(&tt_args));
+        assert!(result.is_ok());
+
+        let result = result.unwrap();
+        let tx = decode_transaction(&[result], TransactionVersion::Testnet).unwrap();
+        assert!(tx.contains("chain_id\":2147483648"));
+
+        // Custom chain id
+        let tt_args = [
+            "--testnet=0x12345678",
+            "token-transfer",
+            "043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3",
+            "1",
+            "0",
+            "ST1A14RBKJ289E3DP89QAZE2RRHDPWP5RHMYFRCHV",
+            "10",
+        ];
+
+        let result = main_handler(to_string_vec(&tt_args));
+        assert!(result.is_ok());
+
+        let result = result.unwrap();
+        let tx = decode_transaction(&[result], TransactionVersion::Testnet).unwrap();
+        assert!(tx.contains("chain_id\":305419896"));
+    }
 }