CRC: get mainnet flag from stacks_client directly

jferrant · jferrant · commit 970b8c431334 · 2024-09-20T15:11:54.000-07:00
Signed-off-by: Jacinta Ferrant &lt;jacinta@trustmachines.co&gt;
diff --git a/libsigner/src/v0/messages.rs b/libsigner/src/v0/messages.rs
@@ -275,6 +275,8 @@ pub struct PeerInfo {
     pub pox_consensus: ConsensusHash,
     /// The server version
     pub server_version: String,
+    /// The network id
+    pub network_id: u32,
 }
 
 impl StacksMessageCodec for PeerInfo {
@@ -287,6 +289,7 @@ impl StacksMessageCodec for PeerInfo {
         fd.write_all(self.server_version.as_bytes())
             .map_err(CodecError::WriteError)?;
         write_next(fd, &self.pox_consensus)?;
+        write_next(fd, &self.network_id)?;
         Ok(())
     }
 
@@ -305,13 +308,15 @@ impl StacksMessageCodec for PeerInfo {
             )
         })?;
         let pox_consensus = read_next::<ConsensusHash, _>(fd)?;
+        let network_id = read_next(fd)?;
         Ok(Self {
             burn_block_height,
             stacks_tip_consensus_hash,
             stacks_tip,
             stacks_tip_height,
             server_version,
             pox_consensus,
+            network_id,
         })
     }
 }
@@ -321,18 +326,15 @@ impl StacksMessageCodec for PeerInfo {
 pub struct MockProposal {
     /// The view of the stacks node peer information at the time of the mock proposal
     pub peer_info: PeerInfo,
-    /// The chain id for the mock proposal
-    pub chain_id: u32,
     /// The miner's signature across the peer info
     signature: MessageSignature,
 }
 
 impl MockProposal {
     /// Create a new mock proposal data struct from the provided peer info, chain id, and private key.
-    pub fn new(peer_info: PeerInfo, chain_id: u32, stacks_private_key: &StacksPrivateKey) -> Self {
+    pub fn new(peer_info: PeerInfo, stacks_private_key: &StacksPrivateKey) -> Self {
         let mut sig = Self {
             signature: MessageSignature::empty(),
-            chain_id,
             peer_info,
         };
         sig.sign(stacks_private_key)
@@ -342,7 +344,8 @@ impl MockProposal {
 
     /// The signature hash for the mock proposal
     pub fn miner_signature_hash(&self) -> Sha256Sum {
-        let domain_tuple = make_structured_data_domain("mock-miner", "1.0.0", self.chain_id);
+        let domain_tuple =
+            make_structured_data_domain("mock-miner", "1.0.0", self.peer_info.network_id);
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
                 (
@@ -375,7 +378,8 @@ impl MockProposal {
 
     /// The signature hash including the miner's signature. Used by signers.
     fn signer_signature_hash(&self) -> Sha256Sum {
-        let domain_tuple = make_structured_data_domain("mock-signer", "1.0.0", self.chain_id);
+        let domain_tuple =
+            make_structured_data_domain("mock-signer", "1.0.0", self.peer_info.network_id);
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
                 (
@@ -413,18 +417,15 @@ impl MockProposal {
 impl StacksMessageCodec for MockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         self.peer_info.consensus_serialize(fd)?;
-        write_next(fd, &self.chain_id)?;
         write_next(fd, &self.signature)?;
         Ok(())
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         let peer_info = PeerInfo::consensus_deserialize(fd)?;
-        let chain_id = read_next::<u32, _>(fd)?;
         let signature = read_next::<MessageSignature, _>(fd)?;
         Ok(Self {
             peer_info,
-            chain_id,
             signature,
         })
     }
@@ -1024,26 +1025,26 @@ mod test {
         let stacks_tip_height = thread_rng().next_u64();
         let server_version = "0.0.0".to_string();
         let pox_consensus_byte: u8 = thread_rng().gen();
+        let network_byte: u8 = thread_rng().gen_range(0..=1);
+        let network_id = if network_byte == 1 {
+            CHAIN_ID_TESTNET
+        } else {
+            CHAIN_ID_MAINNET
+        };
         PeerInfo {
             burn_block_height,
             stacks_tip_consensus_hash: ConsensusHash([stacks_tip_consensus_byte; 20]),
             stacks_tip: BlockHeaderHash([stacks_tip_byte; 32]),
             stacks_tip_height,
             server_version,
             pox_consensus: ConsensusHash([pox_consensus_byte; 20]),
+            network_id,
         }
     }
     fn random_mock_proposal() -> MockProposal {
-        let chain_byte: u8 = thread_rng().gen_range(0..=1);
-        let chain_id = if chain_byte == 1 {
-            CHAIN_ID_TESTNET
-        } else {
-            CHAIN_ID_MAINNET
-        };
         let peer_info = random_peer_data();
         MockProposal {
             peer_info,
-            chain_id,
             signature: MessageSignature::empty(),
         }
     }
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
@@ -266,9 +266,6 @@ pub struct MonitorSignersArgs {
     /// The Stacks node to connect to
     #[arg(long)]
     pub host: String,
-    /// Whether the node is mainnet. Default is false.
-    #[arg(long, default_value = "false")]
-    pub mainnet: bool,
     /// Set the polling interval in seconds.
     #[arg(long, short, default_value = "60")]
     pub interval: u64,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
@@ -75,7 +75,7 @@ pub struct StacksClient {
     /// The chain we are interacting with
     chain_id: u32,
     /// Whether we are mainnet or not
-    mainnet: bool,
+    pub mainnet: bool,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
     /// the auth password for the stacks node
@@ -135,6 +135,28 @@ impl StacksClient {
         }
     }
 
+    /// Create a new signer StacksClient and attempt to connect to the stacks node to determine the version
+    pub fn try_from_host(
+        stacks_private_key: StacksPrivateKey,
+        node_host: String,
+        auth_password: String,
+    ) -> Result<Self, ClientError> {
+        let mut stacks_client = Self::new(stacks_private_key, node_host, auth_password, true);
+        let pubkey = StacksPublicKey::from_private(&stacks_private_key);
+        let info = stacks_client.get_peer_info()?;
+        if info.network_id == CHAIN_ID_MAINNET {
+            stacks_client.mainnet = true;
+            stacks_client.chain_id = CHAIN_ID_MAINNET;
+            stacks_client.tx_version = TransactionVersion::Mainnet;
+        } else {
+            stacks_client.mainnet = false;
+            stacks_client.chain_id = CHAIN_ID_TESTNET;
+            stacks_client.tx_version = TransactionVersion::Testnet;
+        }
+        stacks_client.stacks_address = StacksAddress::p2pkh(stacks_client.mainnet, &pubkey);
+        Ok(stacks_client)
+    }
+
     /// Get our signer address
     pub const fn get_signer_address(&self) -> &StacksAddress {
         &self.stacks_address
diff --git a/stacks-signer/src/monitor_signers.rs b/stacks-signer/src/monitor_signers.rs
@@ -51,15 +51,15 @@ pub struct RewardCycleState {
 }
 
 impl SignerMonitor {
-    /// Create a new `SignerMonitor` instance from the given command line args
+    /// Create a new `SignerMonitor` instance
     pub fn new(args: MonitorSignersArgs) -> Self {
         url::Url::parse(&format!("http://{}", args.host)).expect("Failed to parse node host");
-        let stacks_client = StacksClient::new(
+        let stacks_client = StacksClient::try_from_host(
             StacksPrivateKey::new(), // We don't need a private key to read
             args.host.clone(),
             "FOO".to_string(), // We don't care about authorized paths. Just accessing public info
-            args.mainnet,
-        );
+        )
+        .expect("Failed to connect to provided host.");
         Self {
             stacks_client,
             cycle_state: RewardCycleState::default(),
@@ -93,7 +93,7 @@ impl SignerMonitor {
         for entry in entries {
             let public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice())
                 .expect("Failed to convert signing key to StacksPublicKey");
-            let stacks_address = StacksAddress::p2pkh(self.args.mainnet, &public_key);
+            let stacks_address = StacksAddress::p2pkh(self.stacks_client.mainnet, &public_key);
             self.cycle_state
                 .signers_keys
                 .insert(stacks_address, public_key);
@@ -228,8 +228,8 @@ impl SignerMonitor {
             .cycle_state
             .reward_cycle
             .expect("BUG: reward cycle not set");
-        let contract =
-            MessageSlotID::BlockResponse.stacker_db_contract(self.args.mainnet, reward_cycle);
+        let contract = MessageSlotID::BlockResponse
+            .stacker_db_contract(self.stacks_client.mainnet, reward_cycle);
         info!(
             "Monitoring signers stackerdb. Polling interval: {} secs, Max message age: {} secs, Reward cycle: {reward_cycle}, StackerDB contract: {contract}",
             self.args.interval, self.args.max_age
@@ -252,7 +252,7 @@ impl SignerMonitor {
                     .reward_cycle
                     .expect("BUG: reward cycle not set");
                 let contract = MessageSlotID::BlockResponse
-                    .stacker_db_contract(self.args.mainnet, reward_cycle);
+                    .stacker_db_contract(self.stacks_client.mainnet, reward_cycle);
                 info!(
                     "Reward cycle has changed to {reward_cycle}. Updating stacker db session to StackerDB contract {contract}.",
                 );
