clippy: fix legacy_numeric_constants (#1314)

clippy: legacy_numeric_constants

account-decoder/src/parse_stake.rs

@@ -194,7 +194,7 @@ mod test {
                 voter_pubkey,
                 stake: 20,
                 activation_epoch: 2,
-                deactivation_epoch: std::u64::MAX,
+                deactivation_epoch: u64::MAX,
                 warmup_cooldown_rate: 0.25,
             },
             credits_observed: 10,
@@ -222,7 +222,7 @@ mod test {
                         voter: voter_pubkey.to_string(),
                         stake: 20.to_string(),
                         activation_epoch: 2.to_string(),
-                        deactivation_epoch: std::u64::MAX.to_string(),
+                        deactivation_epoch: u64::MAX.to_string(),
                         warmup_cooldown_rate: 0.25,
                     },
                     credits_observed: 10,

accounts-db/src/accounts_db.rs

@@ -6561,7 +6561,7 @@ impl AccountsDb {
     fn report_store_stats(&self) {
         let mut total_count = 0;
         let mut newest_slot = 0;
-        let mut oldest_slot = std::u64::MAX;
+        let mut oldest_slot = u64::MAX;
         let mut total_bytes = 0;
         let mut total_alive_bytes = 0;
         for (slot, store) in self.storage.iter() {
@@ -13252,7 +13252,7 @@ pub mod tests {
     #[should_panic(expected = "overflow is detected while summing capitalization")]
     fn test_checked_sum_for_capitalization_overflow() {
         assert_eq!(
-            AccountsDb::checked_sum_for_capitalization(vec![1, u64::max_value()].into_iter()),
+            AccountsDb::checked_sum_for_capitalization(vec![1, u64::MAX].into_iter()),
             3
         );
     }

accounts-db/src/accounts_partition.rs

@@ -202,7 +202,7 @@ pub fn pubkey_range_from_partition(
 
     type Prefix = u64;
     const PREFIX_SIZE: usize = mem::size_of::<Prefix>();
-    const PREFIX_MAX: Prefix = Prefix::max_value();
+    const PREFIX_MAX: Prefix = Prefix::MAX;
 
     let mut start_pubkey = [0x00u8; 32];
     let mut end_pubkey = [0xffu8; 32];
@@ -319,7 +319,7 @@ pub fn partition_from_pubkey(
     partition_count: PartitionsPerCycle,
 ) -> PartitionIndex {
     type Prefix = u64;
-    const PREFIX_MAX: Prefix = Prefix::max_value();
+    const PREFIX_MAX: Prefix = Prefix::MAX;
 
     if partition_count == 1 {
         return 0;
@@ -503,11 +503,11 @@ pub(crate) mod tests {
         );
 
         fn should_cause_overflow(partition_count: u64) -> bool {
-            // Check `partition_width = (u64::max_value() + 1) / partition_count` is exact and
+            // Check `partition_width = (u64::MAX + 1) / partition_count` is exact and
             // does not have a remainder.
-            // This way, `partition_width * partition_count == (u64::max_value() + 1)`,
+            // This way, `partition_width * partition_count == (u64::MAX + 1)`,
             // so the test actually tests for overflow
-            (u64::max_value() - partition_count + 1) % partition_count == 0
+            (u64::MAX - partition_count + 1) % partition_count == 0
         }
 
         let max_exact = 64;

accounts-db/src/append_vec.rs

@@ -1320,7 +1320,7 @@ pub mod tests {
             // wrap AppendVec in ManuallyDrop to ensure we do not remove the backing file when dropped
             let av = ManuallyDrop::new(AppendVec::new(path, true, 1024 * 1024));
 
-            let too_large_data_len = u64::max_value();
+            let too_large_data_len = u64::MAX;
             av.append_account_test(&create_test_account(10)).unwrap();
 
             av.get_stored_account_meta_callback(0, |account| {
@@ -1359,7 +1359,7 @@ pub mod tests {
                 av.append_account_test(&executable_account).unwrap()
             };
 
-            let crafted_executable = u8::max_value() - 1;
+            let crafted_executable = u8::MAX - 1;
 
             // reload accounts
             // ensure false is 0u8 and true is 1u8 actually

accounts-db/src/hardened_unpack.rs

@@ -1006,11 +1006,8 @@ mod tests {
         let result = checked_total_size_sum(500, 500, MAX_SNAPSHOT_ARCHIVE_UNPACKED_ACTUAL_SIZE);
         assert_matches!(result, Ok(1000));
 
-        let result = checked_total_size_sum(
-            u64::max_value() - 2,
-            2,
-            MAX_SNAPSHOT_ARCHIVE_UNPACKED_ACTUAL_SIZE,
-        );
+        let result =
+            checked_total_size_sum(u64::MAX - 2, 2, MAX_SNAPSHOT_ARCHIVE_UNPACKED_ACTUAL_SIZE);
         assert_matches!(
             result,
             Err(UnpackError::Archive(ref message))

banking-bench/src/main.rs

@@ -352,7 +352,7 @@ fn main() {
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
         .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+        .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
     let mut all_packets: Vec<PacketsPerIteration> = std::iter::from_fn(|| {
         Some(PacketsPerIteration::new(
@@ -553,11 +553,9 @@ fn main() {
             insert_time.stop();
 
             // set cost tracker limits to MAX so it will not filter out TXs
-            bank.write_cost_tracker().unwrap().set_limits(
-                std::u64::MAX,
-                std::u64::MAX,
-                std::u64::MAX,
-            );
+            bank.write_cost_tracker()
+                .unwrap()
+                .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
             assert!(poh_recorder.read().unwrap().bank().is_none());
             poh_recorder

bench-tps/src/cli.rs

@@ -91,7 +91,7 @@ impl Default for Config {
             websocket_url: ConfigInput::default().websocket_url,
             id: Keypair::new(),
             threads: 4,
-            duration: Duration::new(std::u64::MAX, 0),
+            duration: Duration::new(u64::MAX, 0),
             tx_count: 50_000,
             keypair_multiplier: 8,
             thread_batch_sleep_ms: 1000,

cli/src/cluster_query.rs

@@ -843,7 +843,7 @@ pub fn process_catchup(
         );
     }
 
-    let mut previous_rpc_slot = std::i64::MAX;
+    let mut previous_rpc_slot = i64::MAX;
     let mut previous_slot_distance: i64 = 0;
     let mut retry_count: u64 = 0;
     let max_retry_count = 5;
@@ -928,7 +928,7 @@ pub fn process_catchup(
             },
             node_slot,
             rpc_slot,
-            if slot_distance == 0 || previous_rpc_slot == std::i64::MAX {
+            if slot_distance == 0 || previous_rpc_slot == i64::MAX {
                 "".to_string()
             } else {
                 format!(
@@ -1504,7 +1504,7 @@ pub fn process_ping(
         }
     }
 
-    'mainloop: for seq in 0..count.unwrap_or(std::u64::MAX) {
+    'mainloop: for seq in 0..count.unwrap_or(u64::MAX) {
         let now = Instant::now();
         if fixed_blockhash.is_none() && now.duration_since(blockhash_acquired).as_secs() > 60 {
             // Fetch a new blockhash every minute
@@ -1745,9 +1745,9 @@ pub fn process_live_slots(config: &CliConfig) -> ProcessResult {
     let spacer = "|";
     slot_progress.println(spacer);
 
-    let mut last_root = std::u64::MAX;
+    let mut last_root = u64::MAX;
     let mut last_root_update = Instant::now();
-    let mut slots_per_second = std::f64::NAN;
+    let mut slots_per_second = f64::NAN;
     loop {
         if exit.load(Ordering::Relaxed) {
             eprintln!("{message}");
@@ -1757,7 +1757,7 @@ pub fn process_live_slots(config: &CliConfig) -> ProcessResult {
 
         match receiver.recv() {
             Ok(new_info) => {
-                if last_root == std::u64::MAX {
+                if last_root == u64::MAX {
                     last_root = new_info.root;
                     last_root_update = Instant::now();
                 }

cli/src/stake.rs

@@ -2362,12 +2362,12 @@ pub fn build_stake_state(
                 } else {
                     None
                 },
-                activation_epoch: Some(if stake.delegation.activation_epoch < std::u64::MAX {
+                activation_epoch: Some(if stake.delegation.activation_epoch < u64::MAX {
                     stake.delegation.activation_epoch
                 } else {
                     0
                 }),
-                deactivation_epoch: if stake.delegation.deactivation_epoch < std::u64::MAX {
+                deactivation_epoch: if stake.delegation.deactivation_epoch < u64::MAX {
                     Some(stake.delegation.deactivation_epoch)
                 } else {
                     None
@@ -2622,10 +2622,10 @@ pub fn process_show_stake_history(
         })?;
 
     let limit_results = match config.output_format {
-        OutputFormat::Json | OutputFormat::JsonCompact => std::usize::MAX,
+        OutputFormat::Json | OutputFormat::JsonCompact => usize::MAX,
         _ => {
             if limit_results == 0 {
-                std::usize::MAX
+                usize::MAX
             } else {
                 limit_results
             }

core/benches/banking_stage.rs

@@ -224,7 +224,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
         .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+        .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
     debug!("threads: {} txs: {}", num_threads, txes);
 

core/benches/consumer.rs

@@ -119,7 +119,7 @@ fn setup(apply_cost_tracker_during_replay: bool) -> BenchFrame {
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
         .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+        .set_limits(u64::MAX, u64::MAX, u64::MAX);
     let bank = bank.wrap_with_bank_forks_for_tests().0;
 
     let ledger_path = TempDir::new().unwrap();

core/src/banking_stage/consumer.rs

@@ -1432,7 +1432,7 @@ mod tests {
             ..
         } = create_slow_genesis_config(10_000);
         let mut bank = Bank::new_for_tests(&genesis_config);
-        bank.ns_per_slot = std::u128::MAX;
+        bank.ns_per_slot = u128::MAX;
         if !apply_cost_tracker_during_replay_enabled {
             bank.deactivate_feature(&feature_set::apply_cost_tracker_during_replay::id());
         }
@@ -1665,7 +1665,7 @@ mod tests {
         // set cost tracker limits to MAX so it will not filter out TXs
         bank.write_cost_tracker()
             .unwrap()
-            .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+            .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
         // Transfer more than the balance of the mint keypair, should cause a
         // InstructionError::InsufficientFunds that is then committed. Needs to be
@@ -1726,7 +1726,7 @@ mod tests {
         // set cost tracker limits to MAX so it will not filter out TXs
         bank.write_cost_tracker()
             .unwrap()
-            .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+            .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
         // Make all repetitive transactions that conflict on the `mint_keypair`, so only 1 should be executed
         let mut transactions = vec![

core/src/banking_trace.rs

@@ -432,7 +432,7 @@ mod tests {
         let path = temp_dir.path().join("banking-trace");
         let exit = Arc::<AtomicBool>::default();
         let (tracer, tracer_thread) =
-            BankingTracer::new(Some((&path, exit.clone(), DirByteLimit::max_value()))).unwrap();
+            BankingTracer::new(Some((&path, exit.clone(), DirByteLimit::MAX))).unwrap();
         let (non_vote_sender, non_vote_receiver) = tracer.create_channel_non_vote();
 
         let exit_for_dummy_thread = Arc::<AtomicBool>::default();
@@ -473,7 +473,7 @@ mod tests {
         let path = temp_dir.path().join("banking-trace");
         let exit = Arc::<AtomicBool>::default();
         let (tracer, tracer_thread) =
-            BankingTracer::new(Some((&path, exit.clone(), DirByteLimit::max_value()))).unwrap();
+            BankingTracer::new(Some((&path, exit.clone(), DirByteLimit::MAX))).unwrap();
         let (non_vote_sender, non_vote_receiver) = tracer.create_channel_non_vote();
 
         let dummy_main_thread = thread::spawn(move || {

core/src/cluster_slots_service/cluster_slots.rs

@@ -283,7 +283,7 @@ mod tests {
         let mut map = HashMap::new();
         let k1 = solana_sdk::pubkey::new_rand();
         let k2 = solana_sdk::pubkey::new_rand();
-        map.insert(k1, std::u64::MAX / 2);
+        map.insert(k1, u64::MAX / 2);
         map.insert(k2, 0);
         cs.cluster_slots
             .write()
@@ -291,7 +291,7 @@ mod tests {
             .insert(0, Arc::new(RwLock::new(map)));
         c1.set_pubkey(k1);
         c2.set_pubkey(k2);
-        assert_eq!(cs.compute_weights(0, &[c1, c2]), vec![std::u64::MAX / 4, 1]);
+        assert_eq!(cs.compute_weights(0, &[c1, c2]), vec![u64::MAX / 4, 1]);
     }
 
     #[test]
@@ -311,7 +311,7 @@ mod tests {
         let validator_stakes: HashMap<_, _> = vec![(
             k1,
             NodeVoteAccounts {
-                total_stake: std::u64::MAX / 2,
+                total_stake: u64::MAX / 2,
                 vote_accounts: vec![Pubkey::default()],
             },
         )]
@@ -320,10 +320,7 @@ mod tests {
         *cs.validator_stakes.write().unwrap() = Arc::new(validator_stakes);
         c1.set_pubkey(k1);
         c2.set_pubkey(k2);
-        assert_eq!(
-            cs.compute_weights(0, &[c1, c2]),
-            vec![std::u64::MAX / 4 + 1, 1]
-        );
+        assert_eq!(cs.compute_weights(0, &[c1, c2]), vec![u64::MAX / 4 + 1, 1]);
     }
 
     #[test]
@@ -345,7 +342,7 @@ mod tests {
         let validator_stakes: HashMap<_, _> = vec![(
             *contact_infos[1].pubkey(),
             NodeVoteAccounts {
-                total_stake: std::u64::MAX / 2,
+                total_stake: u64::MAX / 2,
                 vote_accounts: vec![Pubkey::default()],
             },
         )]

core/src/repair/ancestor_hashes_service.rs

@@ -1801,7 +1801,7 @@ mod test {
         // If the request timed out, we should remove the slot from `ancestor_hashes_request_statuses`,
         // and add it to `repairable_dead_slot_pool` or `popular_pruned_slot_pool`.
         // Because the request_throttle is at its limit, we should not immediately retry the timed request.
-        request_throttle.resize(MAX_ANCESTOR_HASHES_SLOT_REQUESTS_PER_SECOND, std::u64::MAX);
+        request_throttle.resize(MAX_ANCESTOR_HASHES_SLOT_REQUESTS_PER_SECOND, u64::MAX);
         AncestorHashesService::manage_ancestor_requests(
             &ancestor_hashes_request_statuses,
             &ancestor_hashes_request_socket,
@@ -1867,7 +1867,7 @@ mod test {
         // 5) If we've reached the throttle limit, no requests should be made,
         // but should still read off the channel for replay updates
         request_throttle.clear();
-        request_throttle.resize(MAX_ANCESTOR_HASHES_SLOT_REQUESTS_PER_SECOND, std::u64::MAX);
+        request_throttle.resize(MAX_ANCESTOR_HASHES_SLOT_REQUESTS_PER_SECOND, u64::MAX);
         let dead_duplicate_confirmed_slot_2 = 15;
         ancestor_hashes_replay_update_sender
             .send(AncestorHashesReplayUpdate::DeadDuplicateConfirmed(

core/src/repair/repair_service.rs

@@ -237,7 +237,7 @@ impl Default for RepairSlotRange {
     fn default() -> Self {
         RepairSlotRange {
             start: 0,
-            end: std::u64::MAX,
+            end: u64::MAX,
         }
     }
 }
@@ -1355,7 +1355,7 @@ mod test {
                 assert_eq!(
                     RepairService::generate_repairs_in_range(
                         &blockstore,
-                        std::usize::MAX,
+                        usize::MAX,
                         &repair_slot_range,
                     ),
                     expected
@@ -1397,11 +1397,7 @@ mod test {
         let repair_slot_range = RepairSlotRange { start: 2, end };
 
         assert_eq!(
-            RepairService::generate_repairs_in_range(
-                &blockstore,
-                std::usize::MAX,
-                &repair_slot_range,
-            ),
+            RepairService::generate_repairs_in_range(&blockstore, usize::MAX, &repair_slot_range,),
             expected
         );
     }
@@ -1461,7 +1457,7 @@ mod test {
         let receive_socket = &UdpSocket::bind("0.0.0.0:0").unwrap();
         let duplicate_status = DuplicateSlotRepairStatus {
             correct_ancestor_to_repair: (dead_slot, Hash::default()),
-            start_ts: std::u64::MAX,
+            start_ts: u64::MAX,
             repair_pubkey_and_addr: None,
         };
 
@@ -1480,7 +1476,7 @@ mod test {
         duplicate_slot_repair_statuses.insert(dead_slot, duplicate_status);
 
         // There is no repair_addr, so should not get filtered because the timeout
-        // `std::u64::MAX` has not expired
+        // `u64::MAX` has not expired
         RepairService::generate_and_send_duplicate_repairs(
             &mut duplicate_slot_repair_statuses,
             &cluster_slots,
@@ -1568,7 +1564,7 @@ mod test {
         // address
         let mut duplicate_status = DuplicateSlotRepairStatus {
             correct_ancestor_to_repair: (dead_slot, Hash::default()),
-            start_ts: std::u64::MAX,
+            start_ts: u64::MAX,
             repair_pubkey_and_addr: dummy_addr,
         };
         RepairService::update_duplicate_slot_repair_addr(
@@ -1583,7 +1579,7 @@ mod test {
         // If the repair address is None, should try to update
         let mut duplicate_status = DuplicateSlotRepairStatus {
             correct_ancestor_to_repair: (dead_slot, Hash::default()),
-            start_ts: std::u64::MAX,
+            start_ts: u64::MAX,
             repair_pubkey_and_addr: None,
         };
         RepairService::update_duplicate_slot_repair_addr(

core/src/repair/repair_weighted_traversal.rs

@@ -344,7 +344,7 @@ pub mod test {
             &blockstore,
             &mut slot_meta_cache,
             &mut repairs,
-            std::usize::MAX,
+            usize::MAX,
         );
         let last_shred = blockstore.meta(0).unwrap().unwrap().received;
         assert_eq!(

core/src/validator.rs

@@ -301,7 +301,7 @@ impl Default for ValidatorConfig {
             repair_validators: None,
             repair_whitelist: Arc::new(RwLock::new(HashSet::default())),
             gossip_validators: None,
-            accounts_hash_interval_slots: std::u64::MAX,
+            accounts_hash_interval_slots: u64::MAX,
             max_genesis_archive_unpacked_size: MAX_GENESIS_ARCHIVE_UNPACKED_SIZE,
             wal_recovery_mode: None,
             run_verification: true,

entry/src/poh.rs

@@ -5,7 +5,7 @@ use {
     std::time::{Duration, Instant},
 };
 
-const LOW_POWER_MODE: u64 = std::u64::MAX;
+const LOW_POWER_MODE: u64 = u64::MAX;
 
 pub struct Poh {
     pub hash: Hash,

genesis/src/stakes.rs

@@ -51,7 +51,7 @@ pub fn create_and_add_stakes(
     // the largest each stake account should be, in lamports
     granularity: Option<u64>,
 ) -> u64 {
-    let granularity = granularity.unwrap_or(std::u64::MAX);
+    let granularity = granularity.unwrap_or(u64::MAX);
     let staker = &staker_info
         .staker
         .parse::<Pubkey>()
@@ -268,7 +268,7 @@ mod tests {
         );
 
         // huge granularity doesn't blow up
-        let granularity = std::u64::MAX;
+        let granularity = u64::MAX;
         let total_lamports = staker_reserve + reserve * 2 + 1;
         create_and_check_stakes(
             &mut GenesisConfig {

ledger-tool/src/main.rs

@@ -334,7 +334,7 @@ fn graph_forks(bank_forks: &BankForks, config: &GraphConfig) -> String {
     // while collecting information about the absent votes and stakes
     let mut absent_stake = 0;
     let mut absent_votes = 0;
-    let mut lowest_last_vote_slot = std::u64::MAX;
+    let mut lowest_last_vote_slot = u64::MAX;
     let mut lowest_total_stake = 0;
     for (node_pubkey, (last_vote_slot, vote_state, stake, total_stake)) in &last_votes {
         all_votes.entry(*node_pubkey).and_modify(|validator_votes| {
@@ -2639,7 +2639,7 @@ fn main() {
                                     detail.voter_owner = *owner;
                                     detail.total_stake = delegation.stake;
                                     detail.activation_epoch = delegation.activation_epoch;
-                                    if delegation.deactivation_epoch < Epoch::max_value() {
+                                    if delegation.deactivation_epoch < Epoch::MAX {
                                         detail.deactivation_epoch =
                                             Some(delegation.deactivation_epoch);
                                     }
@@ -2846,7 +2846,7 @@ fn main() {
                                                 detail.map(|d| d.rent_exempt_reserve),
                                             ),
                                             activation_epoch: format_or_na(detail.map(|d| {
-                                                if d.activation_epoch < Epoch::max_value() {
+                                                if d.activation_epoch < Epoch::MAX {
                                                     d.activation_epoch
                                                 } else {
                                                     // bootstraped

ledger/benches/blockstore_processor.rs

@@ -99,7 +99,7 @@ fn setup(apply_cost_tracker_during_replay: bool) -> BenchFrame {
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
         .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+        .set_limits(u64::MAX, u64::MAX, u64::MAX);
     let bank = bank.wrap_with_bank_forks_for_tests().0;
     let prioritization_fee_cache = PrioritizationFeeCache::default();
     BenchFrame {

ledger/benches/protobuf.rs

@@ -21,7 +21,7 @@ fn create_rewards() -> Rewards {
         .map(|i| Reward {
             pubkey: pubkey::new_rand().to_string(),
             lamports: 42 + i,
-            post_balance: std::u64::MAX,
+            post_balance: u64::MAX,
             reward_type: Some(RewardType::Fee),
             commission: None,
         })

ledger/src/bank_forks_utils.rs

@@ -210,7 +210,7 @@ pub fn load_bank_forks(
     let mut leader_schedule_cache =
         LeaderScheduleCache::new_from_bank(&bank_forks.read().unwrap().root_bank());
     if process_options.full_leader_cache {
-        leader_schedule_cache.set_max_schedules(std::usize::MAX);
+        leader_schedule_cache.set_max_schedules(usize::MAX);
     }
 
     if let Some(ref new_hard_forks) = process_options.new_hard_forks {

ledger/src/blockstore.rs

@@ -5352,7 +5352,7 @@ pub mod tests {
                     let meta = blockstore.meta(num_slots + 1).unwrap().unwrap();
                     assert_eq!(meta.consumed, 1);
                     assert_eq!(meta.received, 1);
-                    assert_eq!(meta.last_index, std::u64::MAX);
+                    assert_eq!(meta.last_index, u64::MAX);
                     assert_eq!(meta.parent_slot, num_slots);
                     assert!(meta.next_slots.is_empty());
 
@@ -10501,7 +10501,7 @@ pub mod tests {
             .map(|i| Reward {
                 pubkey: solana_sdk::pubkey::new_rand().to_string(),
                 lamports: 42 + i,
-                post_balance: std::u64::MAX,
+                post_balance: u64::MAX,
                 reward_type: Some(RewardType::Fee),
                 commission: None,
             })
@@ -10823,7 +10823,7 @@ pub mod tests {
         let even_smaller_last_shred_duplicate = {
             let mut payload = shreds[smaller_last_shred_index - 1].payload().clone();
             // Flip a byte to create a duplicate shred
-            payload[0] = std::u8::MAX - payload[0];
+            payload[0] = u8::MAX - payload[0];
             let mut shred = Shred::new_from_serialized_shred(payload).unwrap();
             shred.set_last_in_slot();
             shred

ledger/src/blockstore_meta.rs

@@ -766,8 +766,8 @@ mod test {
             new_erasure_meta
         );
 
-        new_erasure_meta.first_received_coding_index = u64::from(u32::max_value());
-        old_erasure_meta.__unused_size = usize::try_from(u32::max_value()).unwrap();
+        new_erasure_meta.first_received_coding_index = u64::from(u32::MAX);
+        old_erasure_meta.__unused_size = usize::try_from(u32::MAX).unwrap();
 
         assert_eq!(
             bincode::deserialize::<OldErasureMeta>(&bincode::serialize(&new_erasure_meta).unwrap())

ledger/src/blockstore_options.rs

@@ -212,7 +212,7 @@ pub struct BlockstoreRocksFifoOptions {
     pub shred_code_cf_size: u64,
 }
 
-pub const MAX_ROCKS_FIFO_SHRED_STORAGE_SIZE_BYTES: u64 = std::u64::MAX;
+pub const MAX_ROCKS_FIFO_SHRED_STORAGE_SIZE_BYTES: u64 = u64::MAX;
 
 impl BlockstoreRocksFifoOptions {
     /// Returns a BlockstoreRocksFifoOptions where the specified

ledger/src/blockstore_processor.rs

@@ -3027,7 +3027,7 @@ pub mod tests {
         };
         let (_bank_forks, leader_schedule) =
             test_process_blockstore(&genesis_config, &blockstore, &opts, Arc::default());
-        assert_eq!(leader_schedule.max_schedules(), std::usize::MAX);
+        assert_eq!(leader_schedule.max_schedules(), usize::MAX);
     }
 
     #[test]

ledger/src/leader_schedule_cache.rs

@@ -393,11 +393,11 @@ mod tests {
             pubkey
         );
         assert_eq!(
-            cache.next_leader_slot(&pubkey, 0, &bank, None, std::u64::MAX),
+            cache.next_leader_slot(&pubkey, 0, &bank, None, u64::MAX),
             Some((1, 863_999))
         );
         assert_eq!(
-            cache.next_leader_slot(&pubkey, 1, &bank, None, std::u64::MAX),
+            cache.next_leader_slot(&pubkey, 1, &bank, None, u64::MAX),
             Some((2, 863_999))
         );
         assert_eq!(
@@ -406,7 +406,7 @@ mod tests {
                 2 * genesis_config.epoch_schedule.slots_per_epoch - 1, // no schedule generated for epoch 2
                 &bank,
                 None,
-                std::u64::MAX
+                u64::MAX
             ),
             None
         );
@@ -417,7 +417,7 @@ mod tests {
                 0,
                 &bank,
                 None,
-                std::u64::MAX
+                u64::MAX
             ),
             None
         );
@@ -445,7 +445,7 @@ mod tests {
         // Check that the next leader slot after 0 is slot 1
         assert_eq!(
             cache
-                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), u64::MAX)
                 .unwrap()
                 .0,
             1
@@ -457,7 +457,7 @@ mod tests {
         blockstore.insert_shreds(shreds, None, false).unwrap();
         assert_eq!(
             cache
-                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), u64::MAX)
                 .unwrap()
                 .0,
             1
@@ -470,7 +470,7 @@ mod tests {
         blockstore.insert_shreds(shreds, None, false).unwrap();
         assert_eq!(
             cache
-                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), u64::MAX)
                 .unwrap()
                 .0,
             3
@@ -483,7 +483,7 @@ mod tests {
                 2 * genesis_config.epoch_schedule.slots_per_epoch - 1, // no schedule generated for epoch 2
                 &bank,
                 Some(&blockstore),
-                std::u64::MAX
+                u64::MAX
             ),
             None
         );
@@ -494,7 +494,7 @@ mod tests {
                 0,
                 &bank,
                 Some(&blockstore),
-                std::u64::MAX
+                u64::MAX
             ),
             None
         );
@@ -554,12 +554,12 @@ mod tests {
 
         // If the max root isn't set, we'll get None
         assert!(cache
-            .next_leader_slot(&node_pubkey, 0, &bank, None, std::u64::MAX)
+            .next_leader_slot(&node_pubkey, 0, &bank, None, u64::MAX)
             .is_none());
 
         cache.set_root(&bank);
         let res = cache
-            .next_leader_slot(&node_pubkey, 0, &bank, None, std::u64::MAX)
+            .next_leader_slot(&node_pubkey, 0, &bank, None, u64::MAX)
             .unwrap();
 
         assert_eq!(res.0, expected_slot);
@@ -620,7 +620,7 @@ mod tests {
         cache.set_max_schedules(0);
         assert_eq!(cache.max_schedules(), MAX_SCHEDULES);
 
-        cache.set_max_schedules(std::usize::MAX);
-        assert_eq!(cache.max_schedules(), std::usize::MAX);
+        cache.set_max_schedules(usize::MAX);
+        assert_eq!(cache.max_schedules(), usize::MAX);
     }
 }

ledger/src/shred.rs

@@ -1522,7 +1522,7 @@ mod tests {
             assert_eq!(stats.bad_parent_offset, 1);
         }
         {
-            let index = std::u32::MAX - 10;
+            let index = u32::MAX - 10;
             {
                 let mut cursor = Cursor::new(packet.buffer_mut());
                 cursor

ledger/src/shredder.rs

@@ -57,7 +57,7 @@ impl Shredder {
         reference_tick: u8,
         version: u16,
     ) -> Result<Self, Error> {
-        if slot < parent_slot || slot - parent_slot > u64::from(std::u16::MAX) {
+        if slot < parent_slot || slot - parent_slot > u64::from(u16::MAX) {
             Err(Error::InvalidParentSlot { slot, parent_slot })
         } else {
             Ok(Self {
@@ -710,7 +710,7 @@ mod tests {
         let keypair = Arc::new(Keypair::new());
         let slot = 1;
         let parent_slot = 0;
-        let shredder = Shredder::new(slot, parent_slot, u8::max_value(), 0).unwrap();
+        let shredder = Shredder::new(slot, parent_slot, u8::MAX, 0).unwrap();
         let entries: Vec<_> = (0..5)
             .map(|_| {
                 let keypair0 = Keypair::new();

ledger/src/sigverify_shreds.rs

@@ -608,8 +608,7 @@ mod tests {
         batches[0][0].buffer_mut()[..shred.payload().len()].copy_from_slice(shred.payload());
         batches[0][0].meta_mut().size = shred.payload().len();
 
-        let leader_slots =
-            HashMap::from([(std::u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
+        let leader_slots = HashMap::from([(u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
         let rv = verify_shreds_gpu(
             thread_pool,
             &batches,
@@ -621,7 +620,7 @@ mod tests {
 
         let wrong_keypair = Keypair::new();
         let leader_slots = HashMap::from([
-            (std::u64::MAX, Pubkey::default()),
+            (u64::MAX, Pubkey::default()),
             (slot, wrong_keypair.pubkey()),
         ]);
         let rv = verify_shreds_gpu(
@@ -633,7 +632,7 @@ mod tests {
         );
         assert_eq!(rv, vec![vec![0]]);
 
-        let leader_slots = HashMap::from([(std::u64::MAX, Pubkey::default())]);
+        let leader_slots = HashMap::from([(u64::MAX, Pubkey::default())]);
         let rv = verify_shreds_gpu(
             thread_pool,
             &batches,
@@ -644,8 +643,7 @@ mod tests {
         assert_eq!(rv, vec![vec![0]]);
 
         batches[0][0].meta_mut().size = 0;
-        let leader_slots =
-            HashMap::from([(std::u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
+        let leader_slots = HashMap::from([(u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
         let rv = verify_shreds_gpu(
             thread_pool,
             &batches,
@@ -689,7 +687,7 @@ mod tests {
         let keypair = Keypair::new();
         let pinned_keypair = sign_shreds_gpu_pinned_keypair(&keypair, &recycler_cache);
         let pinned_keypair = Some(Arc::new(pinned_keypair));
-        let pubkeys = HashMap::from([(std::u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
+        let pubkeys = HashMap::from([(u64::MAX, Pubkey::default()), (slot, keypair.pubkey())]);
         //unsigned
         let rv = verify_shreds_gpu(thread_pool, &batches, &pubkeys, &recycler_cache, &cache);
         assert_eq!(rv, vec![vec![0; num_packets]; num_batches]);
@@ -734,7 +732,7 @@ mod tests {
         batches[0][0].buffer_mut()[..shred.payload().len()].copy_from_slice(shred.payload());
         batches[0][0].meta_mut().size = shred.payload().len();
 
-        let pubkeys = HashMap::from([(slot, keypair.pubkey()), (std::u64::MAX, Pubkey::default())]);
+        let pubkeys = HashMap::from([(slot, keypair.pubkey()), (u64::MAX, Pubkey::default())]);
         //unsigned
         let rv = verify_shreds_cpu(thread_pool, &batches, &pubkeys, &cache);
         assert_eq!(rv, vec![vec![0]]);

local-cluster/tests/local_cluster.rs

@@ -2168,7 +2168,7 @@ fn create_snapshot_to_hard_fork(
         ..ProcessOptions::default()
     };
     let ledger_path = blockstore.ledger_path();
-    let genesis_config = open_genesis_config(ledger_path, u64::max_value()).unwrap();
+    let genesis_config = open_genesis_config(ledger_path, u64::MAX).unwrap();
     let snapshot_config = create_simple_snapshot_config(ledger_path);
     let (bank_forks, ..) = bank_forks_utils::load(
         &genesis_config,

programs/bpf_loader/src/syscalls/mod.rs

@@ -765,8 +765,8 @@ declare_builtin_function!(
             invoke_context.get_check_aligned(),
         )?;
 
-        let mut bump_seed = [std::u8::MAX];
-        for _ in 0..std::u8::MAX {
+        let mut bump_seed = [u8::MAX];
+        for _ in 0..u8::MAX {
             {
                 let mut seeds_with_bump = seeds.to_vec();
                 seeds_with_bump.push(&bump_seed);

programs/sbf/benches/bpf_loader.rs

@@ -142,7 +142,7 @@ fn bench_program_alu(bencher: &mut Bencher) {
 
     println!("Interpreted:");
     vm.context_object_pointer
-        .mock_set_remaining(std::i64::MAX as u64);
+        .mock_set_remaining(i64::MAX as u64);
     let (instructions, result) = vm.execute_program(&executable, true);
     assert_eq!(SUCCESS, result.unwrap());
     assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
@@ -153,7 +153,7 @@ fn bench_program_alu(bencher: &mut Bencher) {
 
     bencher.iter(|| {
         vm.context_object_pointer
-            .mock_set_remaining(std::i64::MAX as u64);
+            .mock_set_remaining(i64::MAX as u64);
         vm.execute_program(&executable, true).1.unwrap();
     });
     let summary = bencher.bench(|_bencher| Ok(())).unwrap().unwrap();
@@ -174,7 +174,7 @@ fn bench_program_alu(bencher: &mut Bencher) {
 
     bencher.iter(|| {
         vm.context_object_pointer
-            .mock_set_remaining(std::i64::MAX as u64);
+            .mock_set_remaining(i64::MAX as u64);
         vm.execute_program(&executable, false).1.unwrap();
     });
     let summary = bencher.bench(|_bencher| Ok(())).unwrap().unwrap();

programs/sbf/rust/128bit/src/lib.rs

@@ -12,11 +12,11 @@ pub extern "C" fn entrypoint(_input: *mut u8) -> u64 {
     assert_eq!(y, 170_141_183_460_469_231_731_687_303_715_884_105_728);
 
     assert_eq!(
-        u128::max_value(),
+        u128::MAX,
         340_282_366_920_938_463_463_374_607_431_768_211_455
     );
 
-    let mut z = u128::max_value();
+    let mut z = u128::MAX;
     z -= 1;
     assert_eq!(z, 340_282_366_920_938_463_463_374_607_431_768_211_454);
 
@@ -35,13 +35,10 @@ pub extern "C" fn entrypoint(_input: *mut u8) -> u64 {
     assert_eq!(solana_sbf_rust_128bit_dep::divide(-20, -10), 2i128);
     assert_eq!(solana_sbf_rust_128bit_dep::modulo(-20, -3), -2i128);
 
-    let x = u64::max_value();
+    let x = u64::MAX;
     assert_eq!(u128::from(x) + u128::from(x), 36_893_488_147_419_103_230);
 
-    let x = solana_sbf_rust_128bit_dep::uadd(
-        u128::from(u64::max_value()),
-        u128::from(u64::max_value()),
-    );
+    let x = solana_sbf_rust_128bit_dep::uadd(u128::from(u64::MAX), u128::from(u64::MAX));
     assert_eq!(x.wrapping_shr(64) as u64, 1);
     assert_eq!(
         x.wrapping_shl(64).wrapping_shr(64) as u64,

programs/sbf/rust/custom_heap/src/lib.rs

@@ -13,7 +13,6 @@ use {
         alloc::{alloc, Layout},
         mem::{align_of, size_of},
         ptr::null_mut,
-        usize,
     },
 };
 

programs/sbf/tests/programs.rs

@@ -154,7 +154,7 @@ fn execute_transactions(
         },
     ) = bank.load_execute_and_commit_transactions(
         &batch,
-        std::usize::MAX,
+        usize::MAX,
         true,
         ExecutionRecordingConfig::new_single_setting(true),
         &mut timings,

programs/stake/src/points.rs

@@ -224,7 +224,7 @@ mod tests {
             native_token::sol_to_lamports(10_000_000f64),
             &Pubkey::default(),
             &vote_state,
-            std::u64::MAX,
+            u64::MAX,
         );
 
         let epoch_slots: u128 = 14 * 24 * 3600 * 160;

programs/stake/src/rewards.rs

@@ -238,12 +238,7 @@ mod tests {
         // assume stake.stake() is right
         // bootstrap means fully-vested stake at epoch 0
         let stake_lamports = 1;
-        let mut stake = new_stake(
-            stake_lamports,
-            &Pubkey::default(),
-            &vote_state,
-            std::u64::MAX,
-        );
+        let mut stake = new_stake(stake_lamports, &Pubkey::default(), &vote_state, u64::MAX);
 
         // this one can't collect now, credits_observed == vote_state.credits()
         assert_eq!(
@@ -295,7 +290,7 @@ mod tests {
         let mut vote_state = VoteState::default();
         // assume stake.stake() is right
         // bootstrap means fully-vested stake at epoch 0
-        let mut stake = new_stake(1, &Pubkey::default(), &vote_state, std::u64::MAX);
+        let mut stake = new_stake(1, &Pubkey::default(), &vote_state, u64::MAX);
 
         // this one can't collect now, credits_observed == vote_state.credits()
         assert_eq!(
@@ -624,7 +619,7 @@ mod tests {
             native_token::sol_to_lamports(10_000_000f64),
             &Pubkey::default(),
             &vote_state,
-            std::u64::MAX,
+            u64::MAX,
         );
 
         // this one can't collect now, credits_observed == vote_state.credits()

programs/stake/src/stake_instruction.rs

@@ -2269,7 +2269,7 @@ mod tests {
                     voter_pubkey: vote_address,
                     stake: stake_lamports,
                     activation_epoch: clock.epoch,
-                    deactivation_epoch: std::u64::MAX,
+                    deactivation_epoch: u64::MAX,
                     ..Delegation::default()
                 },
                 credits_observed: vote_state_credits,
@@ -2332,7 +2332,7 @@ mod tests {
         );
         // verify that deactivation has been cleared
         let stake = stake_from(&accounts_2[0]).unwrap();
-        assert_eq!(stake.delegation.deactivation_epoch, std::u64::MAX);
+        assert_eq!(stake.delegation.deactivation_epoch, u64::MAX);
 
         // verify that delegate to a different vote account fails
         // if stake is still active
@@ -2368,7 +2368,7 @@ mod tests {
                     voter_pubkey: vote_address_2,
                     stake: stake_lamports,
                     activation_epoch: clock.epoch,
-                    deactivation_epoch: std::u64::MAX,
+                    deactivation_epoch: u64::MAX,
                     ..Delegation::default()
                 },
                 credits_observed: vote_state_credits,

programs/stake/src/stake_state.rs

@@ -113,7 +113,7 @@ fn redelegate_stake(
             && clock.epoch == stake.delegation.deactivation_epoch
             && stake_lamports_ok
         {
-            stake.delegation.deactivation_epoch = std::u64::MAX;
+            stake.delegation.deactivation_epoch = u64::MAX;
             return Ok(());
         } else {
             // can't redelegate to another pubkey if stake is active.
@@ -126,7 +126,7 @@ fn redelegate_stake(
 
     stake.delegation.stake = stake_lamports;
     stake.delegation.activation_epoch = clock.epoch;
-    stake.delegation.deactivation_epoch = std::u64::MAX;
+    stake.delegation.deactivation_epoch = u64::MAX;
     stake.delegation.voter_pubkey = *voter_pubkey;
     stake.credits_observed = vote_state.credits();
     Ok(())
@@ -1237,7 +1237,7 @@ pub fn create_stake_history_from_delegations(
 
     let bootstrap_delegation = if let Some(bootstrap) = bootstrap {
         vec![Delegation {
-            activation_epoch: std::u64::MAX,
+            activation_epoch: u64::MAX,
             stake: bootstrap,
             ..Delegation::default()
         }]
@@ -1516,7 +1516,7 @@ mod tests {
     #[test]
     fn test_stake_is_bootstrap() {
         assert!(Delegation {
-            activation_epoch: std::u64::MAX,
+            activation_epoch: u64::MAX,
             ..Delegation::default()
         }
         .is_bootstrap());
@@ -2000,7 +2000,7 @@ mod tests {
             Delegation {
                 // never deactivates
                 stake: 1_000,
-                activation_epoch: std::u64::MAX,
+                activation_epoch: u64::MAX,
                 ..Delegation::default()
             },
             Delegation {

programs/zk-token-proof/benches/verify_proofs.rs

@@ -32,7 +32,7 @@ fn bench_pubkey_validity(c: &mut Criterion) {
 }
 
 fn bench_range_proof_u64(c: &mut Criterion) {
-    let amount = std::u64::MAX;
+    let amount = u64::MAX;
     let (commitment, opening) = Pedersen::new(amount);
     let proof_data = RangeProofU64Data::new(&commitment, amount, &opening).unwrap();
 

remote-wallet/src/ledger.rs

@@ -440,7 +440,7 @@ impl RemoteWallet<hidapi::DeviceInfo> for LedgerWallet {
         } else {
             extend_and_serialize_multiple(&[derivation_path])
         };
-        if data.len() > u16::max_value() as usize {
+        if data.len() > u16::MAX as usize {
             return Err(RemoteWalletError::InvalidInput(
                 "Message to sign is too long".to_string(),
             ));

rpc/src/rpc.rs

@@ -7577,7 +7577,7 @@ pub mod tests {
         rpc.block_commitment_cache
             .write()
             .unwrap()
-            .set_highest_super_majority_root(std::u64::MAX);
+            .set_highest_super_majority_root(u64::MAX);
 
         let request = create_test_request(
             "getBlocks",

runtime/src/bank.rs

@@ -6983,7 +6983,7 @@ impl Bank {
     ) -> (Arc<Self>, Arc<RwLock<BankForks>>) {
         let mut bank = Self::new_for_tests(genesis_config);
 
-        bank.ns_per_slot = std::u128::MAX;
+        bank.ns_per_slot = u128::MAX;
         bank.wrap_with_bank_forks_for_tests()
     }
 

runtime/src/bank/tests.rs

@@ -3961,7 +3961,7 @@ fn test_bank_epoch_vote_accounts() {
     let leader_stake = Stake {
         delegation: Delegation {
             stake: leader_lamports,
-            activation_epoch: std::u64::MAX, // bootstrap
+            activation_epoch: u64::MAX, // bootstrap
             ..Delegation::default()
         },
         ..Stake::default()

runtime/src/bank_forks.rs

@@ -127,7 +127,7 @@ impl BankForks {
             banks,
             descendants,
             snapshot_config: None,
-            accounts_hash_interval_slots: std::u64::MAX,
+            accounts_hash_interval_slots: u64::MAX,
             last_accounts_hash_slot: root_slot,
             in_vote_only_mode: Arc::new(AtomicBool::new(false)),
             highest_slot_at_startup: 0,

sdk/program/src/entrypoint_deprecated.rs

@@ -76,7 +76,7 @@ pub unsafe fn deserialize<'a>(input: *mut u8) -> (&'a Pubkey, Vec<AccountInfo<'a
     for _ in 0..num_accounts {
         let dup_info = *(input.add(offset) as *const u8);
         offset += size_of::<u8>();
-        if dup_info == std::u8::MAX {
+        if dup_info == u8::MAX {
             #[allow(clippy::cast_ptr_alignment)]
             let is_signer = *(input.add(offset) as *const u8) != 0;
             offset += size_of::<u8>();

sdk/program/src/fee_calculator.rs

@@ -70,7 +70,7 @@ pub struct FeeRateGovernor {
     pub min_lamports_per_signature: u64,
     pub max_lamports_per_signature: u64,
 
-    // What portion of collected fees are to be destroyed, as a fraction of std::u8::MAX
+    // What portion of collected fees are to be destroyed, as a fraction of u8::MAX
     pub burn_percent: u8,
 }
 
@@ -122,7 +122,7 @@ impl FeeRateGovernor {
                 me.max_lamports_per_signature
                     .min(me.min_lamports_per_signature.max(
                         me.target_lamports_per_signature
-                            * std::cmp::min(latest_signatures_per_slot, std::u32::MAX as u64)
+                            * std::cmp::min(latest_signatures_per_slot, u32::MAX as u64)
                             / me.target_signatures_per_slot,
                     ));
 
@@ -309,7 +309,7 @@ mod tests {
         loop {
             let last_lamports_per_signature = f.lamports_per_signature;
 
-            f = FeeRateGovernor::new_derived(&f, std::u64::MAX);
+            f = FeeRateGovernor::new_derived(&f, u64::MAX);
             info!("[up] f.lamports_per_signature={}", f.lamports_per_signature);
 
             // some maximum target reached

sdk/program/src/pubkey.rs

@@ -504,8 +504,8 @@ impl Pubkey {
         // not supported
         #[cfg(not(target_os = "solana"))]
         {
-            let mut bump_seed = [std::u8::MAX];
-            for _ in 0..std::u8::MAX {
+            let mut bump_seed = [u8::MAX];
+            for _ in 0..u8::MAX {
                 {
                     let mut seeds_with_bump = seeds.to_vec();
                     seeds_with_bump.push(&bump_seed);
@@ -523,7 +523,7 @@ impl Pubkey {
         #[cfg(target_os = "solana")]
         {
             let mut bytes = [0; 32];
-            let mut bump_seed = std::u8::MAX;
+            let mut bump_seed = u8::MAX;
             let result = unsafe {
                 crate::syscalls::sol_try_find_program_address(
                     seeds as *const _ as *const u8,

sdk/program/src/short_vec.rs

@@ -101,9 +101,9 @@ fn visit_byte(elem: u8, val: u16, nth_byte: usize) -> VisitResult {
     }
 
     let shift = u32::try_from(nth_byte)
-        .unwrap_or(std::u32::MAX)
+        .unwrap_or(u32::MAX)
         .saturating_mul(7);
-    let elem_val = elem_val.checked_shl(shift).unwrap_or(std::u32::MAX);
+    let elem_val = elem_val.checked_shl(shift).unwrap_or(u32::MAX);
 
     let new_val = val | elem_val;
     let val = u16::try_from(new_val).map_err(|_| VisitError::Overflow(new_val))?;
@@ -170,7 +170,7 @@ pub fn serialize<S: Serializer, T: Serialize>(
     let mut seq = serializer.serialize_tuple(1)?;
 
     let len = elements.len();
-    if len > std::u16::MAX as usize {
+    if len > u16::MAX as usize {
         return Err(ser::Error::custom("length larger than u16"));
     }
     let short_len = ShortU16(len as u16);
@@ -227,7 +227,7 @@ where
     T: Deserialize<'de>,
 {
     let visitor = ShortVecVisitor { _t: PhantomData };
-    deserializer.deserialize_tuple(std::usize::MAX, visitor)
+    deserializer.deserialize_tuple(usize::MAX, visitor)
 }
 
 pub struct ShortVec<T>(pub Vec<T>);
@@ -362,10 +362,10 @@ mod tests {
 
     #[test]
     fn test_short_vec_u8_too_long() {
-        let vec = ShortVec(vec![4u8; std::u16::MAX as usize]);
+        let vec = ShortVec(vec![4u8; u16::MAX as usize]);
         assert_matches!(serialize(&vec), Ok(_));
 
-        let vec = ShortVec(vec![4u8; std::u16::MAX as usize + 1]);
+        let vec = ShortVec(vec![4u8; u16::MAX as usize + 1]);
         assert_matches!(serialize(&vec), Err(_));
     }
 

sdk/program/src/stake/config.rs

@@ -19,7 +19,7 @@ crate::declare_deprecated_id!("StakeConfig11111111111111111111111111111111");
 pub struct Config {
     /// how much stake we can activate/deactivate per-epoch as a fraction of currently effective stake
     pub warmup_cooldown_rate: f64,
-    /// percentage of stake lost when slash, expressed as a portion of std::u8::MAX
+    /// percentage of stake lost when slash, expressed as a portion of u8::MAX
     pub slash_penalty: u8,
 }
 

sdk/program/src/stake/state.rs

@@ -24,7 +24,7 @@ pub type StakeActivationStatus = StakeHistoryEntry;
 // epoch
 pub const DEFAULT_WARMUP_COOLDOWN_RATE: f64 = 0.25;
 pub const NEW_WARMUP_COOLDOWN_RATE: f64 = 0.09;
-pub const DEFAULT_SLASH_PENALTY: u8 = ((5 * std::u8::MAX as usize) / 100) as u8;
+pub const DEFAULT_SLASH_PENALTY: u8 = ((5 * u8::MAX as usize) / 100) as u8;
 
 pub fn warmup_cooldown_rate(current_epoch: Epoch, new_rate_activation_epoch: Option<Epoch>) -> f64 {
     if current_epoch < new_rate_activation_epoch.unwrap_or(u64::MAX) {
@@ -622,7 +622,7 @@ impl Default for Delegation {
             voter_pubkey: Pubkey::default(),
             stake: 0,
             activation_epoch: 0,
-            deactivation_epoch: std::u64::MAX,
+            deactivation_epoch: u64::MAX,
             warmup_cooldown_rate: DEFAULT_WARMUP_COOLDOWN_RATE,
         }
     }
@@ -638,7 +638,7 @@ impl Delegation {
         }
     }
     pub fn is_bootstrap(&self) -> bool {
-        self.activation_epoch == std::u64::MAX
+        self.activation_epoch == u64::MAX
     }
 
     pub fn stake(
@@ -950,7 +950,7 @@ impl Stake {
     }
 
     pub fn deactivate(&mut self, epoch: Epoch) -> Result<(), StakeError> {
-        if self.delegation.deactivation_epoch != std::u64::MAX {
+        if self.delegation.deactivation_epoch != u64::MAX {
             Err(StakeError::AlreadyDeactivated)
         } else {
             self.delegation.deactivation_epoch = epoch;

sdk/program/src/vote/state/mod.rs

@@ -585,7 +585,7 @@ impl VoteState {
 
         VoteState {
             votes: VecDeque::from(vec![LandedVote::default(); MAX_LOCKOUT_HISTORY]),
-            root_slot: Some(std::u64::MAX),
+            root_slot: Some(u64::MAX),
             epoch_credits: vec![(0, 0, 0); MAX_EPOCH_CREDITS_HISTORY],
             authorized_voters,
             ..Self::default()
@@ -1165,7 +1165,7 @@ mod tests {
         assert_eq!(vote_state.commission_split(1), (0, 1, false));
 
         let mut vote_state = VoteState {
-            commission: std::u8::MAX,
+            commission: u8::MAX,
             ..VoteState::default()
         };
         assert_eq!(vote_state.commission_split(1), (1, 0, false));

sdk/src/ed25519_instruction.rs

@@ -291,8 +291,8 @@ pub mod test {
         );
 
         let offsets = Ed25519SignatureOffsets {
-            message_data_offset: std::u16::MAX,
-            message_data_size: std::u16::MAX,
+            message_data_offset: u16::MAX,
+            message_data_size: u16::MAX,
             ..Ed25519SignatureOffsets::default()
         };
         assert_eq!(
@@ -304,7 +304,7 @@ pub mod test {
     #[test]
     fn test_pubkey_offset() {
         let offsets = Ed25519SignatureOffsets {
-            public_key_offset: std::u16::MAX,
+            public_key_offset: u16::MAX,
             ..Ed25519SignatureOffsets::default()
         };
         assert_eq!(
@@ -325,7 +325,7 @@ pub mod test {
     #[test]
     fn test_signature_offset() {
         let offsets = Ed25519SignatureOffsets {
-            signature_offset: std::u16::MAX,
+            signature_offset: u16::MAX,
             ..Ed25519SignatureOffsets::default()
         };
         assert_eq!(

sdk/src/secp256k1_instruction.rs

@@ -666,7 +666,7 @@
 //!     signatures: &[SecpSignature],
 //!     instruction_index: u8,
 //! ) -> Result<Vec<u8>> {
-//!     assert!(signatures.len() <= u8::max_value().into());
+//!     assert!(signatures.len() <= u8::MAX.into());
 //!
 //!     // We're going to pack all the signatures into the secp256k1 instruction data.
 //!     // Before our signatures though is the signature offset structures
@@ -1142,8 +1142,8 @@ pub mod test {
         );
 
         let offsets = SecpSignatureOffsets {
-            message_data_offset: std::u16::MAX,
-            message_data_size: std::u16::MAX,
+            message_data_offset: u16::MAX,
+            message_data_size: u16::MAX,
             ..SecpSignatureOffsets::default()
         };
         assert_eq!(
@@ -1155,7 +1155,7 @@ pub mod test {
     #[test]
     fn test_eth_offset() {
         let offsets = SecpSignatureOffsets {
-            eth_address_offset: std::u16::MAX,
+            eth_address_offset: u16::MAX,
             ..SecpSignatureOffsets::default()
         };
         assert_eq!(
@@ -1176,7 +1176,7 @@ pub mod test {
     #[test]
     fn test_signature_offset() {
         let offsets = SecpSignatureOffsets {
-            signature_offset: std::u16::MAX,
+            signature_offset: u16::MAX,
             ..SecpSignatureOffsets::default()
         };
         assert_eq!(

thin-client/src/thin_client.rs

@@ -57,7 +57,7 @@ impl ClientOptimizer {
             cur_index: AtomicUsize::new(0),
             experiment_index: AtomicUsize::new(0),
             experiment_done: AtomicBool::new(false),
-            times: RwLock::new(vec![std::u64::MAX; num_clients]),
+            times: RwLock::new(vec![u64::MAX; num_clients]),
             num_clients,
         }
     }
@@ -77,7 +77,7 @@ impl ClientOptimizer {
 
     fn report(&self, index: usize, time_ms: u64) {
         if self.num_clients > 1
-            && (!self.experiment_done.load(Ordering::Relaxed) || time_ms == std::u64::MAX)
+            && (!self.experiment_done.load(Ordering::Relaxed) || time_ms == u64::MAX)
         {
             trace!(
                 "report {} with {} exp: {}",
@@ -88,7 +88,7 @@ impl ClientOptimizer {
 
             self.times.write().unwrap()[index] = time_ms;
 
-            if index == (self.num_clients - 1) || time_ms == std::u64::MAX {
+            if index == (self.num_clients - 1) || time_ms == u64::MAX {
                 let times = self.times.read().unwrap();
                 let (min_time, min_index) = min_index(&times);
                 trace!(
@@ -441,7 +441,7 @@ where
                 Ok((value.0, value.1, value.2))
             }
             Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
+                self.optimizer.report(index, u64::MAX);
                 Err(e.into())
             }
         }
@@ -531,7 +531,7 @@ where
                 Ok(transaction_count)
             }
             Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
+                self.optimizer.report(index, u64::MAX);
                 Err(e.into())
             }
         }
@@ -552,7 +552,7 @@ where
                 Ok(transaction_count)
             }
             Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
+                self.optimizer.report(index, u64::MAX);
                 Err(e.into())
             }
         }
@@ -600,7 +600,7 @@ where
                 Ok((blockhash, last_valid_block_height))
             }
             Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
+                self.optimizer.report(index, u64::MAX);
                 Err(e.into())
             }
         }
@@ -656,7 +656,7 @@ where
 }
 
 fn min_index(array: &[u64]) -> (u64, usize) {
-    let mut min_time = std::u64::MAX;
+    let mut min_time = u64::MAX;
     let mut min_index = 0;
     for (i, time) in array.iter().enumerate() {
         if *time < min_time {
@@ -686,7 +686,7 @@ mod tests {
         optimizer.report(index, 50);
         assert_eq!(optimizer.best(), NUM_CLIENTS - 1);
 
-        optimizer.report(optimizer.best(), std::u64::MAX);
+        optimizer.report(optimizer.best(), u64::MAX);
         assert_eq!(optimizer.best(), NUM_CLIENTS - 2);
     }
 }

tokens/src/commands.rs

@@ -434,7 +434,7 @@ fn send_messages(
         let signers = unique_signers(signers);
         let result: ClientResult<(Transaction, u64)> = {
             if args.dry_run {
-                Ok((Transaction::new_unsigned(message), std::u64::MAX))
+                Ok((Transaction::new_unsigned(message), u64::MAX))
             } else {
                 let (blockhash, last_valid_block_height) =
                     client.get_latest_blockhash_with_commitment(CommitmentConfig::default())?;
@@ -2496,7 +2496,7 @@ mod tests {
             new_stake_account_address: None,
             finalized_date: None,
             transaction: Transaction::new_unsigned(message),
-            last_valid_block_height: std::u64::MAX,
+            last_valid_block_height: u64::MAX,
             lockup_date: None,
         }));
 

zk-sdk/src/range_proof/generators.rs

@@ -54,7 +54,7 @@ impl Iterator for GeneratorsChain {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (usize::max_value(), None)
+        (usize::MAX, None)
     }
 }
 

zk-sdk/src/range_proof/util.rs

@@ -66,7 +66,7 @@ impl Iterator for ScalarExp {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (usize::max_value(), None)
+        (usize::MAX, None)
     }
 }
 

zk-token-sdk/src/instruction/ciphertext_ciphertext_equality.rs

@@ -190,7 +190,7 @@ mod test {
 
         assert!(proof_data.verify_proof().is_ok());
 
-        let amount = u64::max_value();
+        let amount = u64::MAX;
         let source_ciphertext = source_keypair.pubkey().encrypt(amount);
 
         let destination_opening = PedersenOpening::new_rand();

zk-token-sdk/src/instruction/range_proof.rs

@@ -108,7 +108,7 @@ mod test {
 
     #[test]
     fn test_range_proof_64_instruction_correctness() {
-        let amount = std::u64::MAX;
+        let amount = u64::MAX;
         let (commitment, opening) = Pedersen::new(amount);
 
         let proof_data = RangeProofU64Data::new(&commitment, amount, &opening).unwrap();

zk-token-sdk/src/instruction/transfer/with_fee.rs

@@ -859,7 +859,7 @@ mod test {
         assert!(fee_data.verify_proof().is_ok());
 
         // Case 2: transfer max amount
-        let spendable_balance: u64 = u64::max_value();
+        let spendable_balance: u64 = u64::MAX;
         let spendable_ciphertext = source_keypair.pubkey().encrypt(spendable_balance);
 
         let transfer_amount: u64 =

zk-token-sdk/src/instruction/transfer/without_fee.rs

@@ -506,7 +506,7 @@ mod test {
         // Case 2: transfer max amount
 
         // create source account spendable ciphertext
-        let spendable_balance: u64 = u64::max_value();
+        let spendable_balance: u64 = u64::MAX;
         let spendable_ciphertext = source_keypair.pubkey().encrypt(spendable_balance);
 
         // transfer amount

zk-token-sdk/src/range_proof/generators.rs

@@ -55,7 +55,7 @@ impl Iterator for GeneratorsChain {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (usize::max_value(), None)
+        (usize::MAX, None)
     }
 }
 

zk-token-sdk/src/range_proof/util.rs

@@ -65,7 +65,7 @@ impl Iterator for ScalarExp {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (usize::max_value(), None)
+        (usize::MAX, None)
     }
 }