fixed .into() issues, added expected Option for txindex

Author: rdeioris

stackslib/src/burnchains/affirmation.rs

@@ -896,7 +896,7 @@ fn inner_find_heaviest_block_commit_ptr(
     // consider ancestor candidates in _highest_-first order
     for ((height, vtxindex), (block_set, burnt)) in ancestor_confirmations.iter().rev() {
         let confs = block_set.len() as u64;
-        if confs < anchor_threshold.into() {
+        if confs < u64::from(anchor_threshold) {
             continue;
         }
 

stackslib/src/chainstate/coordinator/tests.rs

@@ -1553,7 +1553,7 @@ fn missed_block_commits_2_1() {
             // did we have a bad missed commit in this window?
             // bad missed commits land in the prepare phase.
             let have_bad_missed_commit = b.is_in_prepare_phase(last_bad_op_height)
-                && ix >= MINING_COMMITMENT_WINDOW.into()
+                && ix >= usize::from(MINING_COMMITMENT_WINDOW)
                 && last_bad_op_height + (MINING_COMMITMENT_WINDOW as u64) > tip.block_height;
             if have_bad_missed_commit {
                 // bad commit breaks the chain if its PoX outputs are invalid
@@ -5164,7 +5164,7 @@ fn test_epoch_verify_active_pox_contract() {
 
         let active_pox_contract = b.pox_constants.active_pox_contract(burn_block_height);
 
-        if burn_block_height <= pox_v1_unlock_ht.into() {
+        if burn_block_height <= u64::from(pox_v1_unlock_ht) {
             assert_eq!(active_pox_contract, POX_1_NAME);
             if curr_reward_cycle == 1 {
                 // This is a result of the first stack stx sent.

stackslib/src/chainstate/nakamoto/miner.rs

@@ -692,7 +692,7 @@ impl BlockBuilder for NakamotoBlockBuilder {
         limit_behavior: &BlockLimitFunction,
         ast_rules: ASTRules,
     ) -> TransactionResult {
-        if self.bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
+        if self.bytes_so_far + tx_len >= u64::from(MAX_EPOCH_SIZE) {
             return TransactionResult::skipped_due_to_error(tx, Error::BlockTooBigError);
         }
 

stackslib/src/chainstate/nakamoto/signer_set.rs

@@ -414,7 +414,7 @@ impl NakamotoSigners {
             let cycle_number = value.expect_u128()?;
             // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
             //  the .signers state.
-            Ok(cycle_number < cycle_of_prepare_phase.into())
+            Ok(cycle_number < u128::from(cycle_of_prepare_phase))
         });
 
         if !needs_update? {

stackslib/src/chainstate/stacks/boot/pox_2_tests.rs

@@ -3797,7 +3797,7 @@ fn test_get_pox_addrs() {
                     assert!(opdata.all_outputs_burn());
                     assert!(opdata.burn_fee > 0);
 
-                    if tenure_id > 1 && cur_reward_cycle > lockup_reward_cycle.into() {
+                    if tenure_id > 1 && cur_reward_cycle > u128::from(lockup_reward_cycle) {
                         prepared = true;
                     }
                 }
@@ -3807,7 +3807,7 @@ fn test_get_pox_addrs() {
             for op in burn_ops.iter() {
                 if let BlockstackOperationType::LeaderBlockCommit(ref opdata) = &op {
                     eprintln!("reward phase {}: {:?}", burn_height, opdata);
-                    if tenure_id > 1 && cur_reward_cycle == (lockup_reward_cycle + 1).into() {
+                    if tenure_id > 1 && cur_reward_cycle == u128::from(lockup_reward_cycle + 1) {
                         assert!(!opdata.all_outputs_burn());
                         rewarded = true;
                     } else {
@@ -3874,7 +3874,7 @@ fn test_get_pox_addrs() {
             eprintln!("ntotal_liquid_ustx: {total_liquid_ustx}");
             eprintln!("total-stacked: {total_stacked}");
 
-            if cur_reward_cycle == lockup_reward_cycle.into() {
+            if cur_reward_cycle == u128::from(lockup_reward_cycle) {
                 assert_eq!(reward_addrs.len(), 4);
                 all_reward_addrs = reward_addrs;
             }
@@ -4095,7 +4095,7 @@ fn test_stack_with_segwit() {
                     assert!(opdata.all_outputs_burn());
                     assert!(opdata.burn_fee > 0);
 
-                    if tenure_id > 1 && cur_reward_cycle > lockup_reward_cycle.into() {
+                    if tenure_id > 1 && cur_reward_cycle > u128::from(lockup_reward_cycle) {
                         prepared = true;
                     }
                 }
@@ -4105,7 +4105,7 @@ fn test_stack_with_segwit() {
             for op in burn_ops.iter() {
                 if let BlockstackOperationType::LeaderBlockCommit(ref opdata) = &op {
                     eprintln!("reward phase {}: {:?}", burn_height, opdata);
-                    if tenure_id > 1 && cur_reward_cycle == (lockup_reward_cycle + 1).into() {
+                    if tenure_id > 1 && cur_reward_cycle == u128::from(lockup_reward_cycle + 1) {
                         assert!(!opdata.all_outputs_burn());
                         rewarded = true;
                     } else {
@@ -4172,7 +4172,7 @@ fn test_stack_with_segwit() {
             eprintln!("total_liquid_ustx: {total_liquid_ustx}");
             eprintln!("total-stacked: {total_stacked}");
 
-            if cur_reward_cycle == lockup_reward_cycle.into() {
+            if cur_reward_cycle == u128::from(lockup_reward_cycle) {
                 assert_eq!(reward_addrs.len(), 4);
                 all_reward_addrs = reward_addrs;
             }

stackslib/src/chainstate/stacks/miner.rs

@@ -997,7 +997,7 @@ impl<'a> StacksMicroblockBuilder<'a> {
             ));
         }
 
-        if bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
+        if bytes_so_far + tx_len >= u64::from(MAX_EPOCH_SIZE) {
             info!(
                 "Adding microblock tx {} would exceed epoch data size",
                 &tx.txid()
@@ -1675,7 +1675,7 @@ impl StacksBlockBuilder {
             .map_err(Error::CodecError)?;
         let tx_len = u64::try_from(tx_bytes.len()).expect("tx len exceeds 2^64 bytes");
 
-        if self.bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
+        if self.bytes_so_far + tx_len >= u64::from(MAX_EPOCH_SIZE) {
             warn!(
                 "Epoch size is {} >= {}",
                 self.bytes_so_far + tx_len,
@@ -2733,7 +2733,7 @@ impl BlockBuilder for StacksBlockBuilder {
         limit_behavior: &BlockLimitFunction,
         ast_rules: ASTRules,
     ) -> TransactionResult {
-        if self.bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
+        if self.bytes_so_far + tx_len >= u64::from(MAX_EPOCH_SIZE) {
             return TransactionResult::skipped_due_to_error(tx, Error::BlockTooBigError);
         }
 

stackslib/src/config/mod.rs

@@ -2477,8 +2477,8 @@ pub struct NodeConfigFile {
     pub stacker_dbs: Option<Vec<String>>,
     /// fault injection: fail to push blocks with this probability (0-100)
     pub fault_injection_block_push_fail_probability: Option<u8>,
-    /// enable transactions indexing
-    pub txindex: bool,
+    /// enable transactions indexing, note this will require additional storage (in the order of gigabytes)
+    pub txindex: Option<bool>,
 }
 
 impl NodeConfigFile {
@@ -2578,7 +2578,7 @@ impl NodeConfigFile {
                 default_node_config.fault_injection_block_push_fail_probability
             },
 
-            txindex: self.txindex,
+            txindex: self.txindex.unwrap_or(default_node_config.txindex),
         };
         Ok(node_config)
     }

stackslib/src/core/mempool.rs

@@ -947,7 +947,7 @@ impl<'a> MemPoolTx<'a> {
             // the error rate at or below the target error rate
             let evict_txid = {
                 let num_recents = MemPoolDB::get_num_recent_txs(dbtx)?;
-                if num_recents >= MAX_BLOOM_COUNTER_TXS.into() {
+                if num_recents >= u64::from(MAX_BLOOM_COUNTER_TXS) {
                     // remove lowest-fee tx (they're paying the least, so replication is
                     // deprioritized)
                     let sql = "SELECT a.txid FROM mempool AS a LEFT OUTER JOIN removed_txids AS b ON a.txid = b.txid WHERE b.txid IS NULL AND a.height > ?1 ORDER BY a.tx_fee ASC LIMIT 1";
@@ -2761,7 +2761,7 @@ impl MemPoolDB {
     /// Otherwise, use a MemPoolSyncData::BloomFilter variant
     pub fn make_mempool_sync_data(&self) -> Result<MemPoolSyncData, db_error> {
         let num_tags = MemPoolDB::get_num_recent_txs(self.conn())?;
-        if num_tags < self.max_tx_tags.into() {
+        if num_tags < u64::from(self.max_tx_tags) {
             let seed = self.bloom_counter.get_seed().clone();
             let tags = self.get_txtags(&seed)?;
             Ok(MemPoolSyncData::TxTags(seed, tags))

stackslib/src/net/api/getmicroblocks_unconfirmed.rs

@@ -128,7 +128,7 @@ impl HttpRequest for RPCMicroblocksUnconfirmedRequestHandler {
         let parent_block_id = request::get_block_hash(captures, "parent_block_id")?;
         let start_sequence_u32 = request::get_u32(captures, "start_sequence")?;
 
-        if start_sequence_u32 > u16::MAX.into() {
+        if start_sequence_u32 > u32::from(u16::MAX) {
             return Err(Error::DecodeError("`start_sequence` is too big".into()));
         }
 

stackslib/src/net/api/gettenure.rs

@@ -132,7 +132,7 @@ impl NakamotoTenureStream {
         self.total_sent = self
             .total_sent
             .saturating_add(self.block_stream.total_bytes);
-        if self.total_sent.saturating_add(parent_size) > MAX_PAYLOAD_LEN.into() {
+        if self.total_sent.saturating_add(parent_size) > u64::from(MAX_PAYLOAD_LEN) {
             // out of space to send this
             return Ok(false);
         }