clippy: fix unreadable_literal lint

apoelstra · apoelstra · commit 3ab34e4da8fa · 2025-06-26T02:24:54.000Z
I think this is a style improvement.
diff --git a/src/blech32/mod.rs b/src/blech32/mod.rs
@@ -30,11 +30,11 @@ impl bech32::Checksum for Blech32 {
     type MidstateRepr = u64;
     const CHECKSUM_LENGTH: usize = 12;
     const GENERATOR_SH: [u64; 5] = [
-        0x7d52fba40bd886,
-        0x5e8dbf1a03950c,
-        0x1c3a3c74072a18,
-        0x385d72fa0e5139,
-        0x7093e5a608865b,
+        0x7d_52fb_a40b_d886,
+        0x5e_8dbf_1a03_950c,
+        0x1c_3a3c_7407_2a18,
+        0x38_5d72_fa0e_5139,
+        0x70_93e5_a608_865b,
     ];
     const TARGET_RESIDUE: u64 = 1;
 
@@ -49,13 +49,13 @@ impl bech32::Checksum for Blech32m {
     type MidstateRepr = u64;
     const CHECKSUM_LENGTH: usize = 12;
     const GENERATOR_SH: [u64; 5] = [
-        0x7d52fba40bd886,
-        0x5e8dbf1a03950c,
-        0x1c3a3c74072a18,
-        0x385d72fa0e5139,
-        0x7093e5a608865b,
+        0x7d_52fb_a40b_d886,
+        0x5e_8dbf_1a03_950c,
+        0x1c_3a3c_7407_2a18,
+        0x38_5d72_fa0e_5139,
+        0x70_93e5_a608_865b,
     ];
-    const TARGET_RESIDUE: u64 = 0x455972a3350f7a1;
+    const TARGET_RESIDUE: u64 = 0x455_972a_3350_f7a1;
 
     const CODE_LENGTH: usize = 1024;
 }
diff --git a/src/block.rs b/src/block.rs
@@ -463,7 +463,7 @@ mod tests {
             block.block_hash().to_string(),
             "287ca47e8da47eb8c28d870663450bb026922eadb30a1b2f8293e6e9d1ca5322"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 2);
         assert_eq!(block.txdata.len(), 1);
         assert_eq!(block.size(), serialize(&block).len());
@@ -675,7 +675,7 @@ mod tests {
             block.block_hash().to_string(),
             "e935d06cf3a616eb4d551338598b84daa0e8592ed14673263597f6af4b4a6ea6"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 1);
         assert_eq!(block.txdata.len(), 3);
         assert_eq!(block.size(), serialize(&block).len());
@@ -706,7 +706,7 @@ mod tests {
             block.block_hash().to_string(),
             "bcc6eb2ab6c97b9b4590825b9136f100b22e090c0469818572b8b93926a79f28"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         if let ExtData::Proof { challenge, solution } = block.header.ext {
             assert_eq!(challenge.len(), 1 + 3 * 34 + 2);
             assert_eq!(solution.len(), 144);
@@ -740,7 +740,7 @@ mod tests {
             block.block_hash().to_string(),
             "4961df970cf12d789383974e6ab439f780d956b5a50162ca9d281362e46c605a"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
 
         // Full current and proposal
         let block: Block = hex_deserialize!("\
diff --git a/src/confidential.rs b/src/confidential.rs
@@ -1168,7 +1168,7 @@ mod tests {
             &[
                 Token::Seq { len: Some(2) },
                 Token::U8(1),
-                Token::U64(63601271583539200),
+                Token::U64(63_601_271_583_539_200),
                 Token::SeqEnd
             ]
         );
diff --git a/src/encode.rs b/src/encode.rs
@@ -260,7 +260,7 @@ impl VarInt {
         match self.0 {
             0..=0xFC => 1,
             0xFD..=0xFFFF => 3,
-            0x10000..=0xFFFFFFFF => 5,
+            0x10000..=0xFFFF_FFFF => 5,
             _ => 9,
         }
     }
diff --git a/src/endian.rs b/src/endian.rs
@@ -20,6 +20,6 @@ mod tests {
 
     #[test]
     fn endianness_test() {
-        assert_eq!(u32_to_array_le(0xdeadbeef), [0xef, 0xbe, 0xad, 0xde]);
+        assert_eq!(u32_to_array_le(0xdead_beef), [0xef, 0xbe, 0xad, 0xde]);
     }
 }
diff --git a/src/ext.rs b/src/ext.rs
@@ -119,7 +119,7 @@ impl<W: io::Write + ?Sized> WriteExt for W {
                 self.emit_u16(i as u16)?;
                 Ok(3)
             }
-            i @ 0x10000..=0xFFFFFFFF => {
+            i @ 0x10000..=0xFFFF_FFFF => {
                 self.emit_u8(0xFE)?;
                 self.emit_u32(i as u32)?;
                 Ok(5)
@@ -166,7 +166,7 @@ impl<R: io::Read + ?Sized> ReadExt for R {
         match self.read_u8()? {
             0xFF => {
                 let x = self.read_u64()?;
-                if x < 0x100000000 {
+                if x < 0x1_0000_0000 {
                     Err(encode::Error::NonMinimalVarInt)
                 } else {
                     Ok(x)
diff --git a/src/script.rs b/src/script.rs
@@ -786,17 +786,17 @@ impl Builder {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA1.into_u8());
                 self.0.push(n as u8);
             },
-            n if n < 0x10000 => {
+            n if n < 0x1_0000 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA2.into_u8());
                 self.0.push((n % 0x100) as u8);
                 self.0.push((n / 0x100) as u8);
             },
-            n if n < 0x100000000 => {
+            n if n < 0x1_0000_0000 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA4.into_u8());
                 self.0.push((n % 0x100) as u8);
                 self.0.push(((n / 0x100) % 0x100) as u8);
-                self.0.push(((n / 0x10000) % 0x100) as u8);
-                self.0.push((n / 0x1000000) as u8);
+                self.0.push(((n / 0x1_0000) % 0x100) as u8);
+                self.0.push((n / 0x100_0000) as u8);
             }
             _ => panic!("tried to put a 4bn+ sized object into a script!")
         }
@@ -977,10 +977,10 @@ mod test {
         script = script.push_scriptint(4); comp.extend([1u8, 4].iter().copied()); assert_eq!(&script[..], &comp[..]);
         // big ints
         script = script.push_int(17); comp.extend([1u8, 17].iter().copied()); assert_eq!(&script[..], &comp[..]);
-        script = script.push_int(10000); comp.extend([2u8, 16, 39].iter().copied()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(10_000); comp.extend([2u8, 16, 39].iter().copied()); assert_eq!(&script[..], &comp[..]);
         // notice the sign bit set here, hence the extra zero/128 at the end
-        script = script.push_int(10000000); comp.extend([4u8, 128, 150, 152, 0].iter().copied()); assert_eq!(&script[..], &comp[..]);
-        script = script.push_int(-10000000); comp.extend([4u8, 128, 150, 152, 128].iter().copied()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(10_000_000); comp.extend([4u8, 128, 150, 152, 0].iter().copied()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(-10_000_000); comp.extend([4u8, 128, 150, 152, 128].iter().copied()); assert_eq!(&script[..], &comp[..]);
 
         // data
         script = script.push_slice(b"NRA4VR"); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().copied()); assert_eq!(&script[..], &comp[..]);
@@ -1097,7 +1097,7 @@ mod test {
         assert_eq!(build_scriptint(256), vec![0, 1]);
         assert_eq!(build_scriptint(257), vec![1, 1]);
         assert_eq!(build_scriptint(511), vec![255, 1]);
-        for &i in &[10, 100, 255, 256, 1000, 10000, 25000, 200000, 5000000, 1000000000,
+        for &i in &[10, 100, 255, 256, 1000, 10000, 25000, 200_000, 5_000_000, 1_000_000_000,
                              (1 << 31) - 1, -((1 << 31) - 1)] {
             assert_eq!(Ok(i), read_scriptint(&build_scriptint(i)));
             assert_eq!(Ok(-i), read_scriptint(&build_scriptint(-i)));
diff --git a/src/sighash.rs b/src/sighash.rs
@@ -212,7 +212,7 @@ impl<'s> ScriptPath<'s> {
     }
     /// Create a new `ScriptPath` structure using default values for `code_separator_pos` and `leaf_version`
     pub fn with_defaults(script: &'s Script) -> Self {
-        Self::new(script, 0xFFFFFFFFu32, 0xc4)
+        Self::new(script, 0xFFFF_FFFFu32, 0xc4)
     }
 
     /// Compute the leaf hash
@@ -483,7 +483,7 @@ impl<R: Deref<Target = Transaction>> SighashCache<R> {
             input_index,
             prevouts,
             None,
-            Some((leaf_hash.into(), 0xFFFFFFFF)),
+            Some((leaf_hash.into(), 0xFFFF_FFFF)),
             sighash_type,
             genesis_hash
         )?;
diff --git a/src/transaction.rs b/src/transaction.rs
@@ -187,7 +187,7 @@ impl Sequence {
     /// The maximum allowable sequence number.
     ///
     /// This sequence number disables lock-time and replace-by-fee.
-    pub const MAX: Self = Sequence(0xFFFFFFFF);
+    pub const MAX: Self = Sequence(0xFFFF_FFFF);
     /// Zero value sequence.
     ///
     /// This sequence number enables replace-by-fee and lock-time.
@@ -197,7 +197,7 @@ impl Sequence {
     pub const ENABLE_LOCKTIME_NO_RBF: Self = Sequence::MIN_NO_RBF;
     /// The sequence number that enables replace-by-fee and absolute lock-time but
     /// disables relative lock-time.
-    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFFFFFD);
+    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFF_FFFD);
 
     /// The lowest sequence number that does not opt-in for replace-by-fee.
     ///
@@ -206,11 +206,11 @@ impl Sequence {
     /// (Explicit Signalling [BIP-125]).
     ///
     /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki]>
-    const MIN_NO_RBF: Self = Sequence(0xFFFFFFFE);
+    const MIN_NO_RBF: Self = Sequence(0xFFFF_FFFE);
     /// BIP-68 relative lock-time disable flag mask
-    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x80000000;
+    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x8000_0000;
     /// BIP-68 relative lock-time type flag mask
-    const LOCK_TYPE_MASK: u32 = 0x00400000;
+    const LOCK_TYPE_MASK: u32 = 0x0040_0000;
 
     /// Returns `true` if the sequence number indicates that the transaction is finalised.
     ///
@@ -545,7 +545,7 @@ impl Decodable for TxIn {
         let has_issuance;
         // Pegin/issuance flags are encoded into the high bits of `vout`, *except*
         // if vout is all 1's; this indicates a coinbase transaction
-        if outp.vout == 0xffffffff {
+        if outp.vout == 0xffff_ffff {
             is_pegin = false;
             has_issuance = false;
         } else {
@@ -1373,10 +1373,10 @@ mod tests {
         assert_eq!(tx.weight(), tx.size() * 4);
         assert!(!tx.output[0].is_fee());
         assert!(tx.output[1].is_fee());
-        assert_eq!(tx.output[0].value, confidential::Value::Explicit(9999996700));
-        assert_eq!(tx.output[1].value, confidential::Value::Explicit(      3300));
-        assert_eq!(tx.output[0].minimum_value(), 9999996700);
-        assert_eq!(tx.output[1].minimum_value(),       3300);
+        assert_eq!(tx.output[0].value, confidential::Value::Explicit(9_999_996_700));
+        assert_eq!(tx.output[1].value, confidential::Value::Explicit(3300));
+        assert_eq!(tx.output[0].minimum_value(), 9_999_996_700);
+        assert_eq!(tx.output[1].minimum_value(), 3300);
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
         assert_eq!(tx.fee_in(fee_asset), 3300);
         assert_eq!(tx.all_fees()[&fee_asset], 3300);
@@ -1688,7 +1688,7 @@ mod tests {
                     ).unwrap(),
                     vout: 0,
                 },
-                value: 100000000,
+                value: 100_000_000,
                 asset: tx.output[0].asset.explicit().unwrap(),
                 genesis_hash: bitcoin::BlockHash::from_str(
                     "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
@@ -1803,7 +1803,7 @@ mod tests {
             tx.output[0].pegout_data(),
             Some(super::PegoutData {
                 asset: tx.output[0].asset,
-                value: 99993900,
+                value: 99_993_900,
                 genesis_hash: bitcoin::BlockHash::from_str(
                     "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
                 ).unwrap(),

Original file line number	Diff line number	Diff line change
`@@ -1168,7 +1168,7 @@ mod tests {`
`1168`	`1168`	`&[`
`1169`	`1169`	`Token::Seq { len: Some(2) },`
`1170`	`1170`	`Token::U8(1),`
`1171`		`- Token::U64(63601271583539200),`
	`1171`	`+ Token::U64(63_601_271_583_539_200),`
`1172`	`1172`	`Token::SeqEnd`
`1173`	`1173`	`]`
`1174`	`1174`	`);`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ impl VarInt {`
`260`	`260`	`match self.0 {`
`261`	`261`	`0..=0xFC => 1,`
`262`	`262`	`0xFD..=0xFFFF => 3,`
`263`		`- 0x10000..=0xFFFFFFFF => 5,`
	`263`	`+ 0x10000..=0xFFFF_FFFF => 5,`
`264`	`264`	`_ => 9,`
`265`	`265`	`}`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,6 @@ mod tests {`
`20`	`20`
`21`	`21`	`#[test]`
`22`	`22`	`fn endianness_test() {`
`23`		`- assert_eq!(u32_to_array_le(0xdeadbeef), [0xef, 0xbe, 0xad, 0xde]);`
	`23`	`+ assert_eq!(u32_to_array_le(0xdead_beef), [0xef, 0xbe, 0xad, 0xde]);`
`24`	`24`	`}`
`25`	`25`	`}`