From 5f59618e71e79b9671c8d010d054e05f2bae79f4 Mon Sep 17 00:00:00 2001 From: Turtle Date: Thu, 8 Oct 2026 12:05:12 -0500 Subject: [PATCH 1/2] ci: take yanked secp256k1 0.32.0-beta.2 from its git tag rgb-lib 0.3.0-beta.7 requires secp256k1 ^0.32.0-beta.2, which has been yanked from crates.io. This repo doesn't commit Cargo.lock, so every CI run resolves from scratch and fails with 'version 0.32.0-beta.2 is yanked'. Patch the crate to the commit of its secp256k1-0.32.0-beta.2 tag; git sources aren't subject to yanking, and other secp256k1 versions in the graph still come from crates.io. Co-Authored-By: Claude --- Cargo.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index e262cd090..1f16f8c53 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -43,6 +43,11 @@ opt-level = 2 opt-level = 1 lto = "off" +# rgb-lib needs secp256k1 ^0.32.0-beta.2, which is yanked from crates.io. Without a committed +# lockfile a fresh resolve can't select it, so take it from its git tag (tag secp256k1-0.32.0-beta.2) +[patch.crates-io] +secp256k1 = { git = "https://github.com/rust-bitcoin/rust-secp256k1", rev = "6e5c556e566d6ca1954daa1d8592efac70e75d06" } + [profile.release] opt-level = 3 lto = true From 8d14869bd9d120edc8b70096eb3ca4308a266ee7 Mon Sep 17 00:00:00 2001 From: Turtle Date: Thu, 8 Oct 2026 13:27:11 -0500 Subject: [PATCH 2/2] Fix clippy lints on Rust 1.99 Since the Rust toolchain specified in .github/workflows/build.yml is floating and points to the latest "stable" Rust version, the lint now lints on Rust 1.99.0, which means new lint errors that we need to fix. Replace deprecated max_value() and core::uN::MAX with MAX, use vec![] and unwrap_or where clippy asks, add a missing semicolon, and allow the deprecated fetch_update since its replacement is far newer than our MSRV. Co-Authored-By: Claude --- lightning-background-processor/src/lib.rs | 2 +- lightning-invoice/src/lib.rs | 2 +- lightning-liquidity/src/lsps2/service.rs | 2 + lightning/src/blinded_path/payment.rs | 14 ++--- lightning/src/chain/chaininterface.rs | 2 +- lightning/src/chain/channelmonitor.rs | 2 +- lightning/src/chain/package.rs | 6 +-- lightning/src/ln/channel.rs | 14 ++--- lightning/src/ln/channelmanager.rs | 2 +- lightning/src/ln/msgs.rs | 5 +- lightning/src/ln/onion_utils.rs | 4 +- lightning/src/ln/outbound_payment.rs | 2 +- lightning/src/ln/peer_channel_encryptor.rs | 4 +- lightning/src/ln/peer_handler.rs | 3 +- lightning/src/routing/gossip.rs | 26 +++++----- lightning/src/routing/router.rs | 60 +++++++++++----------- lightning/src/routing/scoring.rs | 60 +++++++++++----------- lightning/src/sign/mod.rs | 2 +- 18 files changed, 105 insertions(+), 107 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index 31e519b9f..e1122c4ac 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -1534,7 +1534,7 @@ impl BackgroundProcessor { SCORER_PERSISTENCE_KEY, scorer.encode(), ) { - log_error!(logger, "Error: Failed to persist scorer, check your disk and permissions {}", e) + log_error!(logger, "Error: Failed to persist scorer, check your disk and permissions {}", e); } } } diff --git a/lightning-invoice/src/lib.rs b/lightning-invoice/src/lib.rs index 1731b2198..6deb7192b 100644 --- a/lightning-invoice/src/lib.rs +++ b/lightning-invoice/src/lib.rs @@ -1596,7 +1596,7 @@ impl Bolt11Invoice { pub fn would_expire(&self, at_time: Duration) -> bool { self.duration_since_epoch() .checked_add(self.expiry_time()) - .unwrap_or_else(|| Duration::new(u64::max_value(), 1_000_000_000 - 1)) + .unwrap_or_else(|| Duration::new(u64::MAX, 1_000_000_000 - 1)) < at_time } diff --git a/lightning-liquidity/src/lsps2/service.rs b/lightning-liquidity/src/lsps2/service.rs index 50b58371a..6d5f18b9e 100644 --- a/lightning-liquidity/src/lsps2/service.rs +++ b/lightning-liquidity/src/lsps2/service.rs @@ -1720,6 +1720,8 @@ where ) -> Option { match peer_state_lock.pending_requests.remove(request_id) { Some(req) => { + // `try_update` is the new name, but is far newer than our MSRV + #[allow(deprecated)] let res = self.total_pending_requests.fetch_update( Ordering::Relaxed, Ordering::Relaxed, diff --git a/lightning/src/blinded_path/payment.rs b/lightning/src/blinded_path/payment.rs index 37d7a1dba..53b4662ba 100644 --- a/lightning/src/blinded_path/payment.rs +++ b/lightning/src/blinded_path/payment.rs @@ -101,7 +101,7 @@ impl BlindedPaymentPath { { // This value is not considered in pathfinding for 1-hop blinded paths, because it's intended to // be in relation to a specific channel. - let htlc_maximum_msat = u64::max_value(); + let htlc_maximum_msat = u64::MAX; Self::new( &[], payee_node_id, @@ -886,7 +886,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, PaymentForwardNode { node_id: dummy_pk, @@ -904,7 +904,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, ]; let recv_tlvs = UnauthenticatedReceiveTlvs { @@ -961,7 +961,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, PaymentForwardNode { node_id: dummy_pk, @@ -979,7 +979,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, ]; let recv_tlvs = UnauthenticatedReceiveTlvs { @@ -1020,7 +1020,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, PaymentForwardNode { node_id: dummy_pk, @@ -1038,7 +1038,7 @@ mod tests { next_blinding_override: None, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: u64::max_value(), + htlc_maximum_msat: u64::MAX, }, ]; let recv_tlvs = UnauthenticatedReceiveTlvs { diff --git a/lightning/src/chain/chaininterface.rs b/lightning/src/chain/chaininterface.rs index 5dc46d5a0..709efb4a7 100644 --- a/lightning/src/chain/chaininterface.rs +++ b/lightning/src/chain/chaininterface.rs @@ -21,7 +21,7 @@ use bitcoin::transaction::Transaction; // TODO: Define typed abstraction over feerates to handle their conversions. pub(crate) fn compute_feerate_sat_per_1000_weight(fee_sat: u64, weight: u64) -> u32 { - (fee_sat * 1000 / weight).try_into().unwrap_or(u32::max_value()) + (fee_sat * 1000 / weight).try_into().unwrap_or(u32::MAX) } pub(crate) const fn fee_for_weight(feerate_sat_per_1000_weight: u32, weight: u64) -> u64 { ((feerate_sat_per_1000_weight as u64 * weight) + 1000 - 1) / 1000 diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs index bf6e51325..1794c5396 100644 --- a/lightning/src/chain/channelmonitor.rs +++ b/lightning/src/chain/channelmonitor.rs @@ -7219,7 +7219,7 @@ mod tests { let witness = $sighash_parts.witness_mut($idx).unwrap(); witness.push(ser_sig); if *$weight == WEIGHT_REVOKED_OUTPUT { - witness.push(vec!(1)); + witness.push(vec![1]); } else if *$weight == weight_revoked_offered_htlc($opt_anchors) || *$weight == weight_revoked_received_htlc($opt_anchors) { witness.push(pubkey.clone().serialize().to_vec()); } else if *$weight == weight_received_htlc($opt_anchors) { diff --git a/lightning/src/chain/package.rs b/lightning/src/chain/package.rs index db46f3be6..1a4ce0eca 100644 --- a/lightning/src/chain/package.rs +++ b/lightning/src/chain/package.rs @@ -900,7 +900,7 @@ impl PackageSolvingData { let mut ser_sig = sig.serialize_der().to_vec(); ser_sig.push(EcdsaSighashType::All as u8); bumped_tx.input[i].witness.push(ser_sig); - bumped_tx.input[i].witness.push(vec!(1)); + bumped_tx.input[i].witness.push(vec![1]); bumped_tx.input[i].witness.push(witness_script.clone().into_bytes()); } else { return false; } }, @@ -1546,7 +1546,7 @@ impl PackageTemplate { ) -> u32 where F::Target: FeeEstimator { let feerate_estimate = fee_estimator.bounded_sat_per_1000_weight(conf_target); if self.feerate_previous != 0 { - let previous_feerate = self.feerate_previous.try_into().unwrap_or(u32::max_value()); + let previous_feerate = self.feerate_previous.try_into().unwrap_or(u32::MAX); match feerate_strategy { FeerateStrategy::RetryPrevious => previous_feerate, FeerateStrategy::HighestOfPreviousOrNew => cmp::max(previous_feerate, feerate_estimate), @@ -1558,7 +1558,7 @@ impl PackageTemplate { // so we choose to bump our previous feerate by 25%, making sure we don't use a // lower feerate or overpay by a large margin by limiting it to 5x the new fee // estimate. - let previous_feerate = self.feerate_previous.try_into().unwrap_or(u32::max_value()); + let previous_feerate = self.feerate_previous.try_into().unwrap_or(u32::MAX); let mut new_feerate = previous_feerate.saturating_add(previous_feerate / 4); if new_feerate > feerate_estimate * 5 { new_feerate = cmp::max(feerate_estimate * 5, previous_feerate); diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index 79ab65373..6c9373a87 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -5873,9 +5873,9 @@ where dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, buffer_dust_limit_success_sat * 1000); } - if htlc_stats.on_holder_tx_dust_exposure_msat as i64 + buffer_dust_limit_timeout_sat as i64 * 1000 - 1 > max_dust_htlc_exposure_msat.try_into().unwrap_or(i64::max_value()) { + if htlc_stats.on_holder_tx_dust_exposure_msat as i64 + buffer_dust_limit_timeout_sat as i64 * 1000 - 1 > max_dust_htlc_exposure_msat.try_into().unwrap_or(i64::MAX) { remaining_msat_below_dust_exposure_limit = Some(cmp::min( - remaining_msat_below_dust_exposure_limit.unwrap_or(u64::max_value()), + remaining_msat_below_dust_exposure_limit.unwrap_or(u64::MAX), max_dust_htlc_exposure_msat.saturating_sub(htlc_stats.on_holder_tx_dust_exposure_msat))); dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, buffer_dust_limit_timeout_sat * 1000); } @@ -7407,7 +7407,7 @@ where // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop // these, but for now we just have to treat them as normal. - let mut pending_idx = core::usize::MAX; + let mut pending_idx = usize::MAX; let mut htlc_value_msat = 0; for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() { if htlc.htlc_id == htlc_id_arg { @@ -7444,7 +7444,7 @@ where break; } } - if pending_idx == core::usize::MAX { + if pending_idx == usize::MAX { return UpdateFulfillFetch::DuplicateClaim {}; } @@ -7648,7 +7648,7 @@ where // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop // these, but for now we just have to treat them as normal. - let mut pending_idx = core::usize::MAX; + let mut pending_idx = usize::MAX; for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() { if htlc.htlc_id == htlc_id_arg { match htlc.state { @@ -7664,7 +7664,7 @@ where pending_idx = idx; } } - if pending_idx == core::usize::MAX { + if pending_idx == usize::MAX { return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc_id_arg))); } @@ -10353,7 +10353,7 @@ where let normal_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee); let mut proposed_max_feerate = - if self.funding.is_outbound() { normal_feerate } else { u32::max_value() }; + if self.funding.is_outbound() { normal_feerate } else { u32::MAX }; // The spec requires that (when the channel does not have anchors) we only send absolute // channel fees no greater than the absolute channel fee on the current commitment diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index 6a9a2cc32..1ff820b76 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -6428,7 +6428,7 @@ where } } - if funding_transaction.output.len() > u16::max_value() as usize { + if funding_transaction.output.len() > u16::MAX as usize { result = result.and(Err(APIError::APIMisuseError { err: "Transaction had more than 2^16 outputs, which is not supported".to_owned() })); diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs index bbd8522f7..045b9fe98 100644 --- a/lightning/src/ln/msgs.rs +++ b/lightning/src/ln/msgs.rs @@ -4350,10 +4350,7 @@ impl QueryChannelRange { /// /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`. pub fn end_blocknum(&self) -> u32 { - match self.first_blocknum.checked_add(self.number_of_blocks) { - Some(block) => block, - None => u32::max_value(), - } + self.first_blocknum.checked_add(self.number_of_blocks).unwrap_or(u32::MAX) } } diff --git a/lightning/src/ln/onion_utils.rs b/lightning/src/ln/onion_utils.rs index e50ecfeb9..7e5029678 100644 --- a/lightning/src/ln/onion_utils.rs +++ b/lightning/src/ln/onion_utils.rs @@ -3264,7 +3264,7 @@ mod tests { // Note that we represent the test vector payloads 2 and 5 through RawOnionHopData::data // with raw hex instead of our in-memory enums, as the payloads contains custom types, and // we have no way of representing that with our enums. - let payloads = vec!( + let payloads = vec![ RawOnionHopData::new(msgs::OutboundOnionPayload::Forward { short_channel_id: 1, amt_to_forward: 15000, @@ -3319,7 +3319,7 @@ mod tests { RawOnionHopData { data: >::from_hex("fd011002022710040203e8082224a33562c54507a9334e79f0dc4f17d407e6d7c61f0e2f3d0d38599502f617042710fd012de02a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a").unwrap(), }, - ); + ]; // Verify that the serialized OnionHopDataFormat::NonFinalNode tlv payloads matches the test vectors let mut w = VecWriter(Vec::new()); diff --git a/lightning/src/ln/outbound_payment.rs b/lightning/src/ln/outbound_payment.rs index 3a4fd4ff9..fa4014ab0 100644 --- a/lightning/src/ln/outbound_payment.rs +++ b/lightning/src/ln/outbound_payment.rs @@ -2194,7 +2194,7 @@ impl OutboundPayments { continue 'path_check; } let dest_hop_idx = if path.blinded_tail.is_some() && path.blinded_tail.as_ref().unwrap().hops.len() > 1 { - usize::max_value() } else { path.hops.len() - 1 }; + usize::MAX } else { path.hops.len() - 1 }; for (idx, hop) in path.hops.iter().enumerate() { if idx != dest_hop_idx && hop.pubkey == our_node_id { path_errs.push(Err(APIError::InvalidRoute{err: "Path went through us but wasn't a simple rebalance loop to us".to_owned()})); diff --git a/lightning/src/ln/peer_channel_encryptor.rs b/lightning/src/ln/peer_channel_encryptor.rs index fbf8193e2..17880d41d 100644 --- a/lightning/src/ln/peer_channel_encryptor.rs +++ b/lightning/src/ln/peer_channel_encryptor.rs @@ -33,7 +33,7 @@ use core::ops::Deref; /// Maximum Lightning message data length according to /// [BOLT-8](https://github.com/lightning/bolts/blob/v1.0/08-transport.md#lightning-message-specification) /// and [BOLT-1](https://github.com/lightning/bolts/blob/master/01-messaging.md#lightning-message-format): -pub const LN_MAX_MSG_LEN: usize = ::core::u16::MAX as usize; // Must be equal to 65535 +pub const LN_MAX_MSG_LEN: usize = u16::MAX as usize; // Must be equal to 65535 /// The (rough) size buffer to pre-allocate when encoding a message. Messages should reliably be /// smaller than this size by at least 32 bytes or so. @@ -1052,7 +1052,7 @@ mod tests { #[test] fn max_msg_len_limit_value() { assert_eq!(LN_MAX_MSG_LEN, 65535); - assert_eq!(LN_MAX_MSG_LEN, ::core::u16::MAX as usize); + assert_eq!(LN_MAX_MSG_LEN, u16::MAX as usize); } #[test] diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 8ae548b3b..1dc486045 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -3607,8 +3607,7 @@ where // be absurd. We ensure this by checking that at least 100 (our stated public contract on when // broadcast_node_announcement panics) of the maximum-length addresses would fit in a 64KB // message... - const HALF_MESSAGE_IS_ADDRS: u32 = - ::core::u16::MAX as u32 / (SocketAddress::MAX_LEN as u32 + 1) / 2; + const HALF_MESSAGE_IS_ADDRS: u32 = u16::MAX as u32 / (SocketAddress::MAX_LEN as u32 + 1) / 2; #[allow(dead_code)] // ...by failing to compile if the number of addresses that would be half of a message is // smaller than 100: diff --git a/lightning/src/routing/gossip.rs b/lightning/src/routing/gossip.rs index f063ac080..41903269d 100644 --- a/lightning/src/routing/gossip.rs +++ b/lightning/src/routing/gossip.rs @@ -862,7 +862,7 @@ where msg: GossipTimestampFilter { chain_hash: self.network_graph.chain_hash, first_timestamp: gossip_start_time as u32, // 2106 issue! - timestamp_range: u32::max_value(), + timestamp_range: u32::MAX, }, }); Ok(()) @@ -1198,8 +1198,8 @@ impl Readable for ChannelInfo { announcement_received_time, (default_value, 0) ), - node_one_counter: u32::max_value(), - node_two_counter: u32::max_value(), + node_one_counter: u32::MAX, + node_two_counter: u32::MAX, contract_id: _init_tlv_based_struct_field!(contract_id, option), }) } @@ -1361,7 +1361,7 @@ impl EffectiveCapacity { EffectiveCapacity::AdvertisedMaxHTLC { amount_msat } => *amount_msat, EffectiveCapacity::Total { capacity_msat, .. } => *capacity_msat, EffectiveCapacity::HintMaxHTLC { amount_msat } => *amount_msat, - EffectiveCapacity::Infinite => u64::max_value(), + EffectiveCapacity::Infinite => u64::MAX, EffectiveCapacity::Unknown => UNKNOWN_CHANNEL_CAPACITY_MSAT, } } @@ -1641,7 +1641,7 @@ impl Readable for NodeInfo { Ok(NodeInfo { announcement_info: announcement_info_wrap.map(|w| w.0), channels, - node_counter: u32::max_value(), + node_counter: u32::MAX, }) } } @@ -1698,7 +1698,7 @@ where let nodes_count: u64 = Readable::read(reader)?; // There shouldn't be anywhere near `u32::MAX` nodes, and we need some headroom to insert // new nodes during sync, so reject any graphs claiming more than `u32::MAX / 2` nodes. - if nodes_count > u32::max_value() as u64 / 2 { + if nodes_count > u32::MAX as u64 / 2 { return Err(DecodeError::InvalidValue); } let mut nodes = IndexedMap::with_capacity(NODE_COUNT_ESTIMATE); @@ -1814,7 +1814,7 @@ where let nodes = self.nodes.read().unwrap(); let removed_node_counters = self.removed_node_counters.lock().unwrap(); let next_counter = self.next_node_counter.load(Ordering::Acquire); - assert!(next_counter < (u32::max_value() as usize) / 2); + assert!(next_counter < (u32::MAX as usize) / 2); let mut used_node_counters = vec![0u8; next_counter / 8 + 1]; for counter in removed_node_counters.iter() { @@ -2047,8 +2047,8 @@ where capacity_sats, announcement_message: None, announcement_received_time: timestamp, - node_one_counter: u32::max_value(), - node_two_counter: u32::max_value(), + node_one_counter: u32::MAX, + node_two_counter: u32::MAX, contract_id: None, }; @@ -2240,8 +2240,8 @@ where None }, announcement_received_time, - node_one_counter: u32::max_value(), - node_two_counter: u32::max_value(), + node_one_counter: u32::MAX, + node_two_counter: u32::MAX, contract_id: msg.contract_id, }; @@ -2373,7 +2373,7 @@ where pub fn remove_stale_channels_and_tracking_with_time(&self, current_time_unix: u64) { let mut channels = self.channels.write().unwrap(); // Time out if we haven't received an update in at least 14 days. - if current_time_unix > u32::max_value() as u64 { + if current_time_unix > u32::MAX as u64 { return; } // Remove by 2106 if current_time_unix < STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS { @@ -3877,7 +3877,7 @@ pub(crate) mod tests { (msg.first_timestamp as u64) < expected_timestamp - 60 * 60 * 24 * 7 * 2 + 10 ); - assert_eq!(msg.timestamp_range, u32::max_value()); + assert_eq!(msg.timestamp_range, u32::MAX); }, _ => panic!("Expected MessageSendEvent::SendChannelRangeQuery"), }; diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 6334de04a..5679e7162 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -677,7 +677,7 @@ impl Readable for Route { let path_count: u64 = Readable::read(reader)?; if path_count == 0 { return Err(DecodeError::InvalidValue); } let mut paths = Vec::with_capacity(cmp::min(path_count, 128) as usize); - let mut min_final_cltv_expiry_delta = u32::max_value(); + let mut min_final_cltv_expiry_delta = u32::MAX; for _ in 0..path_count { let hop_count: u8 = Readable::read(reader)?; let mut hops: Vec = Vec::with_capacity(hop_count as usize); @@ -2015,7 +2015,7 @@ fn max_htlc_from_capacity(capacity: EffectiveCapacity, max_channel_saturation_po let saturation_shift: u32 = max_channel_saturation_power_of_half as u32; match capacity { EffectiveCapacity::ExactLiquidity { liquidity_msat } => liquidity_msat, - EffectiveCapacity::Infinite => u64::max_value(), + EffectiveCapacity::Infinite => u64::MAX, EffectiveCapacity::Unknown => EffectiveCapacity::Unknown.as_msat(), EffectiveCapacity::AdvertisedMaxHTLC { amount_msat } => amount_msat.checked_shr(saturation_shift).unwrap_or(0), @@ -2133,7 +2133,7 @@ impl<'a> PaymentPath<'a> { } fn get_path_penalty_msat(&self) -> u64 { - self.hops.first().map(|h| h.0.path_penalty_msat).unwrap_or(u64::max_value()) + self.hops.first().map(|h| h.0.path_penalty_msat).unwrap_or(u64::MAX) } fn get_total_fee_paid_msat(&self) -> u64 { @@ -2315,7 +2315,7 @@ fn compute_fees(amount_msat: u64, channel_fees: RoutingFees) -> Option { #[rustfmt::skip] fn compute_fees_saturating(amount_msat: u64, channel_fees: RoutingFees) -> u64 { amount_msat.checked_mul(channel_fees.proportional_millionths as u64) - .map(|prop| prop / 1_000_000).unwrap_or(u64::max_value()) + .map(|prop| prop / 1_000_000).unwrap_or(u64::MAX) .saturating_add(channel_fees.base_msat as u64) } @@ -2575,7 +2575,7 @@ where L::Target: Logger { |info| info.features().supports_basic_mpp())) } else { false }; - let max_total_routing_fee_msat = route_params.max_total_routing_fee_msat.unwrap_or(u64::max_value()); + let max_total_routing_fee_msat = route_params.max_total_routing_fee_msat.unwrap_or(u64::MAX); let first_hop_count = first_hops.map(|hops| hops.len()).unwrap_or(0); log_trace!(logger, "Searching for a route from payer {} to {} {} MPP and {} first hops {}overriding the network graph of {} nodes and {} channels with a fee limit of {} msat", @@ -2974,11 +2974,11 @@ where L::Target: Logger { *dist_entry = Some(PathBuildingHop { candidate: $candidate.clone(), fee_msat: 0, - next_hops_fee_msat: u64::max_value(), - hop_use_fee_msat: u64::max_value(), - total_fee_msat: u64::max_value(), + next_hops_fee_msat: u64::MAX, + hop_use_fee_msat: u64::MAX, + total_fee_msat: u64::MAX, path_htlc_minimum_msat, - path_penalty_msat: u64::max_value(), + path_penalty_msat: u64::MAX, was_processed: false, is_first_hop_target: false, is_last_hop_target: false, @@ -3286,15 +3286,15 @@ where L::Target: Logger { candidate: CandidateRouteHop::FirstHop(FirstHopCandidate { details: &chans[0], payer_node_id: &our_node_id, - target_node_counter: u32::max_value(), - payer_node_counter: u32::max_value(), + target_node_counter: u32::MAX, + payer_node_counter: u32::MAX, }), fee_msat: 0, - next_hops_fee_msat: u64::max_value(), - hop_use_fee_msat: u64::max_value(), - total_fee_msat: u64::max_value(), - path_htlc_minimum_msat: u64::max_value(), - path_penalty_msat: u64::max_value(), + next_hops_fee_msat: u64::MAX, + hop_use_fee_msat: u64::MAX, + total_fee_msat: u64::MAX, + path_htlc_minimum_msat: u64::MAX, + path_penalty_msat: u64::MAX, was_processed: false, is_first_hop_target: true, is_last_hop_target: false, @@ -3319,11 +3319,11 @@ where L::Target: Logger { *entry = Some(PathBuildingHop { candidate: candidates[0].clone(), fee_msat: 0, - next_hops_fee_msat: u64::max_value(), - hop_use_fee_msat: u64::max_value(), - total_fee_msat: u64::max_value(), - path_htlc_minimum_msat: u64::max_value(), - path_penalty_msat: u64::max_value(), + next_hops_fee_msat: u64::MAX, + hop_use_fee_msat: u64::MAX, + total_fee_msat: u64::MAX, + path_htlc_minimum_msat: u64::MAX, + path_penalty_msat: u64::MAX, was_processed: false, is_first_hop_target: false, is_last_hop_target: true, @@ -3428,7 +3428,7 @@ where L::Target: Logger { // traversing the graph and arrange the path out of what we found. if node_counter == payer_node_counter { let mut new_entry = dist[payer_node_counter as usize].take().unwrap(); - let mut ordered_hops: Vec<(PathBuildingHop, NodeFeatures)> = vec!((new_entry.clone(), default_node_features.clone())); + let mut ordered_hops: Vec<(PathBuildingHop, NodeFeatures)> = vec![(new_entry.clone(), default_node_features.clone())]; 'path_walk: loop { let mut features_set = false; @@ -3526,7 +3526,7 @@ where L::Target: Logger { // we'll probably end up picking the same path again on the next iteration. // Decrease the available liquidity of a hop in the middle of the path. let victim_candidate = &payment_path.hops[(payment_path.hops.len()) / 2].0.candidate; - let exhausted = u64::max_value(); + let exhausted = u64::MAX; log_trace!(logger, "Disabling route candidate {} for future path building iterations to avoid duplicates.", LoggedCandidateHop(victim_candidate)); @@ -3912,7 +3912,7 @@ fn build_route_from_hops_internal( break; } } - u64::max_value() + u64::MAX } } @@ -6611,8 +6611,8 @@ mod tests { cltv_expiry_delta: (5 << 4) | 5, htlc_minimum_msat: 0, htlc_maximum_msat: 99_000, - fee_base_msat: u32::max_value(), - fee_proportional_millionths: u32::max_value(), + fee_base_msat: u32::MAX, + fee_proportional_millionths: u32::MAX, excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { @@ -6624,8 +6624,8 @@ mod tests { cltv_expiry_delta: (5 << 4) | 3, htlc_minimum_msat: 0, htlc_maximum_msat: 99_000, - fee_base_msat: u32::max_value(), - fee_proportional_millionths: u32::max_value(), + fee_base_msat: u32::MAX, + fee_proportional_millionths: u32::MAX, excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { @@ -7278,7 +7278,7 @@ mod tests { type ScoreParams = (); #[rustfmt::skip] fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { - if candidate.short_channel_id() == Some(self.short_channel_id) { u64::max_value() } else { 0 } + if candidate.short_channel_id() == Some(self.short_channel_id) { u64::MAX } else { 0 } } } @@ -7296,7 +7296,7 @@ mod tests { type ScoreParams = (); #[rustfmt::skip] fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { - if candidate.target() == Some(self.node_id) { u64::max_value() } else { 0 } + if candidate.target() == Some(self.node_id) { u64::MAX } else { 0 } } } diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs index cf5dbc032..036e3e2a4 100644 --- a/lightning/src/routing/scoring.rs +++ b/lightning/src/routing/scoring.rs @@ -706,7 +706,7 @@ pub struct ProbabilisticScoringFeeParameters { pub historical_liquidity_penalty_amount_multiplier_msat: u64, /// Manual penalties used for the given nodes. Allows to set a particular penalty for a given - /// node. Note that a manual penalty of `u64::max_value()` means the node would not ever be + /// node. Note that a manual penalty of `u64::MAX` means the node would not ever be /// considered during path finding. /// /// This is not exported to bindings users @@ -731,7 +731,7 @@ pub struct ProbabilisticScoringFeeParameters { /// applicable, are still included in the overall penalty. /// /// If you wish to avoid creating paths with such channels entirely, setting this to a value of - /// `u64::max_value()` will guarantee that. + /// `u64::MAX` will guarantee that. /// /// Default value: 1_0000_0000_000 msat (1 Bitcoin) /// @@ -809,14 +809,14 @@ impl ProbabilisticScoringFeeParameters { /// Marks the node with the given `node_id` as banned, /// i.e it will be avoided during path finding. pub fn add_banned(&mut self, node_id: &NodeId) { - self.manual_node_penalties.insert(*node_id, u64::max_value()); + self.manual_node_penalties.insert(*node_id, u64::MAX); } /// Marks all nodes in the given list as banned, i.e., /// they will be avoided during path finding. pub fn add_banned_from_list(&mut self, node_ids: Vec) { for id in node_ids { - self.manual_node_penalties.insert(id, u64::max_value()); + self.manual_node_penalties.insert(id, u64::MAX); } } @@ -1338,7 +1338,7 @@ fn linear_success_probability( (max_liquidity_msat - min_liquidity_msat).saturating_add(1)); if min_zero_implies_no_successes && min_liquidity_msat == 0 && - denominator < u64::max_value() / MIN_ZERO_IMPLIES_NO_SUCCESSES_PENALTY_ON_64 + denominator < u64::MAX / MIN_ZERO_IMPLIES_NO_SUCCESSES_PENALTY_ON_64 { denominator = denominator * MIN_ZERO_IMPLIES_NO_SUCCESSES_PENALTY_ON_64 / 64 } @@ -1699,7 +1699,7 @@ where EffectiveCapacity::HintMaxHTLC { amount_msat } => { if usage.amount_msat > amount_msat { - return u64::max_value(); + return u64::MAX; } else { return base_penalty_msat; } @@ -1805,7 +1805,7 @@ where } fn probe_successful(&mut self, path: &Path, duration_since_epoch: Duration) { - self.payment_path_failed(path, u64::max_value(), duration_since_epoch) + self.payment_path_failed(path, u64::MAX, duration_since_epoch) } fn time_passed(&mut self, duration_since_epoch: Duration) { @@ -2032,7 +2032,7 @@ mod bucketed_history { #[inline] #[rustfmt::skip] fn amount_to_pos(amount_msat: u64, capacity_msat: u64) -> u16 { - let pos = if amount_msat < u64::max_value() / (POSITION_TICKS as u64) { + let pos = if amount_msat < u64::MAX / (POSITION_TICKS as u64) { (amount_msat * (POSITION_TICKS as u64) / capacity_msat.saturating_add(1)) .try_into().unwrap_or(POSITION_TICKS) } else { @@ -3059,7 +3059,7 @@ mod tests { let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { liquidity_penalty_multiplier_msat: 1_000, - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let decay_params = ProbabilisticScoringDecayParameters { @@ -3088,9 +3088,9 @@ mod tests { assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 0); let usage = ChannelUsage { amount_msat: 50, ..usage }; assert_ne!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 0); - assert_ne!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_ne!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); let usage = ChannelUsage { amount_msat: 61, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); } #[test] @@ -3174,7 +3174,7 @@ mod tests { let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { liquidity_penalty_multiplier_msat: 1_000, - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); @@ -3203,9 +3203,9 @@ mod tests { let usage = ChannelUsage { amount_msat: 250, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 300); let usage = ChannelUsage { amount_msat: 500, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); let usage = ChannelUsage { amount_msat: 750, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); } #[test] @@ -3354,7 +3354,7 @@ mod tests { let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { liquidity_penalty_multiplier_msat: 1_000, - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let decay_params = ProbabilisticScoringDecayParameters { @@ -3390,7 +3390,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 768, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 1_479); let usage = ChannelUsage { amount_msat: 896, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); // Half decay (i.e., three-quarter life) scorer.time_passed(Duration::from_secs(5)); @@ -3401,7 +3401,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 768, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 921); let usage = ChannelUsage { amount_msat: 896, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); // One decay (i.e., half life) scorer.time_passed(Duration::from_secs(10)); @@ -3412,7 +3412,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 896, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 1_970); let usage = ChannelUsage { amount_msat: 960, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); // Fully decay liquidity lower bound. scorer.time_passed(Duration::from_secs(10 * 8)); @@ -3423,20 +3423,20 @@ mod tests { let usage = ChannelUsage { amount_msat: 1_023, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 2_000); let usage = ChannelUsage { amount_msat: 1_024, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); // Fully decay liquidity upper bound. scorer.time_passed(Duration::from_secs(10 * 9)); let usage = ChannelUsage { amount_msat: 0, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 0); let usage = ChannelUsage { amount_msat: 1_024, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); scorer.time_passed(Duration::from_secs(10 * 10)); let usage = ChannelUsage { amount_msat: 0, ..usage }; assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 0); let usage = ChannelUsage { amount_msat: 1_024, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); } #[test] @@ -3499,7 +3499,7 @@ mod tests { let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { liquidity_penalty_multiplier_msat: 1_000, - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let decay_params = ProbabilisticScoringDecayParameters { @@ -3521,7 +3521,7 @@ mod tests { info, short_channel_id: 42, }); - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); scorer.time_passed(Duration::from_secs(10)); assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), 473); @@ -3544,7 +3544,7 @@ mod tests { let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { liquidity_penalty_multiplier_msat: 1_000, - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let decay_params = ProbabilisticScoringDecayParameters { @@ -3566,7 +3566,7 @@ mod tests { info, short_channel_id: 42, }); - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); if decay_before_reload { scorer.time_passed(Duration::from_secs(10)); @@ -3746,7 +3746,7 @@ mod tests { let network_graph = network_graph(&logger); let source = source_node_id(); let usage = ChannelUsage { - amount_msat: u64::max_value(), + amount_msat: u64::MAX, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Infinite, }; @@ -3771,7 +3771,7 @@ mod tests { let logger = TestLogger::new(); let network_graph = network_graph(&logger); let params = ProbabilisticScoringFeeParameters { - considered_impossible_penalty_msat: u64::max_value(), + considered_impossible_penalty_msat: u64::MAX, ..ProbabilisticScoringFeeParameters::zero_penalty() }; let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); @@ -3789,10 +3789,10 @@ mod tests { info, short_channel_id: 42, }); - assert_ne!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_ne!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); let usage = ChannelUsage { inflight_htlc_msat: 251, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); } #[test] @@ -3823,7 +3823,7 @@ mod tests { assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), base_penalty_msat); let usage = ChannelUsage { amount_msat: 1_001, ..usage }; - assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, ¶ms), u64::MAX); } #[test] diff --git a/lightning/src/sign/mod.rs b/lightning/src/sign/mod.rs index 58eaeccac..c5ebef03b 100644 --- a/lightning/src/sign/mod.rs +++ b/lightning/src/sign/mod.rs @@ -2477,7 +2477,7 @@ impl SignerProvider for KeysManager { // roll over, we may generate duplicate keys for two different channels, which could result // in loss of funds. Because we only support 32-bit+ systems, assert that our `AtomicUsize` // doesn't reach `u32::MAX`. - assert!(child_idx < core::u32::MAX as usize, "2^32 channels opened without restart"); + assert!(child_idx < u32::MAX as usize, "2^32 channels opened without restart"); let mut id = [0; 32]; id[0..4].copy_from_slice(&(child_idx as u32).to_be_bytes()); id[4..8].copy_from_slice(&self.starting_time_nanos.to_be_bytes());