Merge pull request #833 from sethdusek/rust1.87

sethdusek · web-flow · commit 6f12ef8f2b2e · 2025-06-15T01:01:46.000+05:00
Bump rust-toolchain to rust 1.87
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -238,7 +238,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-11-23
+          toolchain: nightly-2025-03-28
           override: true
 
       - name: install deps
diff --git a/Cargo.toml b/Cargo.toml
@@ -86,13 +86,13 @@ tokio-stream = { version = "0.1.8", features = ["sync", "time"] }
 tokio-util = { version = "0.6.9", features = ["codec"] }
 bounded-integer = { version = "^0.5", features = ["types"] }
 url = "2.5.4"
-getrandom = { version = "0.2.7" }
+getrandom = { version = "0.2.16" }
 itertools = { version = "0.10.3", default-features = false }
 miette = { version = "5", features = ["fancy"] }
 hashbrown = { version = "0.14.3", features = ["serde"] }
 core2 = { version = "0.4.0", default-features = false, features = ["alloc"] }
 # dev-dependencies
-proptest = { version = "1.5.0", default-features = false, features = [
+proptest = { version = "=1.6.0", default-features = false, features = [
     "alloc",
     "std",
 ] }
diff --git a/bindings/ergo-lib-c-core/src/constant.rs b/bindings/ergo-lib-c-core/src/constant.rs
@@ -178,8 +178,7 @@ pub unsafe fn constant_to_ergo_box(
     let b = constant
         .0
         .clone()
-        .try_extract_into::<ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox>()
-        .map(Into::into)?;
+        .try_extract_into::<ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox>()?;
     *ergo_box_out = Box::into_raw(Box::new(ErgoBox(b)));
     Ok(())
 }
diff --git a/bindings/ergo-lib-wasm/src/ast/js_conv.rs b/bindings/ergo-lib-wasm/src/ast/js_conv.rs
@@ -45,7 +45,7 @@ pub enum ConvError {
     #[error("not supported: {0:?}")]
     NotSupported(JsValue),
     #[error("unexpected constant: {0:?}")]
-    UnexpectedConst(Constant),
+    UnexpectedConst(Box<Constant>),
     #[error("unexpected js value: {0:?}, expected {1}")]
     UnexpectedJs(JsValue, &'static str),
     #[error("IO error: {0}")]
@@ -172,7 +172,7 @@ pub(crate) fn constant_to_js(c: Constant) -> Result<JsValue, ConvError> {
                 }
                 arr.into()
             }
-            _ => return Err(ConvError::UnexpectedConst(c)),
+            _ => return Err(ConvError::UnexpectedConst(c.into())),
         },
         SType::STuple(ref item_tpes) => {
             let vec: Vec<JsValue> = match c.v {
@@ -181,15 +181,15 @@ pub(crate) fn constant_to_js(c: Constant) -> Result<JsValue, ConvError> {
                     .zip(item_tpes.clone().items.into_iter())
                     .map(|(v, tpe)| constant_to_js(Constant { tpe, v }))
                     .collect::<Result<Vec<JsValue>, _>>()?,
-                _ => return Err(ConvError::UnexpectedConst(c.clone())),
+                _ => return Err(ConvError::UnexpectedConst(c.clone().into())),
             };
             let arr = Array::new();
             for item in vec {
                 arr.push(&item);
             }
             arr.into()
         }
-        _ => return Err(ConvError::UnexpectedConst(c.clone())),
+        _ => return Err(ConvError::UnexpectedConst(c.clone().into())),
     })
 }
 
diff --git a/ergo-chain-generation/src/chain_generation.rs b/ergo-chain-generation/src/chain_generation.rs
@@ -142,7 +142,7 @@ fn prove_block(
     // Ergo test suite uses randomly generated value for ad_proofs_root.
     let mut rng = thread_rng();
     let how_many: usize = rng.gen_range(0..5000);
-    let mut ad_proofs_bytes: Vec<u8> = std::iter::repeat(0_u8).take(how_many).collect();
+    let mut ad_proofs_bytes: Vec<u8> = vec![0; how_many];
     for x in &mut ad_proofs_bytes {
         *x = rng.gen();
     }
diff --git a/ergo-chain-generation/src/fake_pow_scheme.rs b/ergo-chain-generation/src/fake_pow_scheme.rs
@@ -86,7 +86,7 @@ mod tests {
         // Ergo test suite uses randomly generated value for ad_proofs_root.
         let mut rng = thread_rng();
         let how_many: usize = rng.gen_range(0..5000);
-        let mut ad_proofs_bytes: Vec<u8> = std::iter::repeat(0_u8).take(how_many).collect();
+        let mut ad_proofs_bytes: Vec<u8> = vec![0; how_many];
         for x in &mut ad_proofs_bytes {
             *x = rng.gen();
         }
@@ -147,7 +147,7 @@ mod tests {
         let x = DlogProverInput::random();
 
         let (sk, _) = default_miner_secret();
-        let nonce: Vec<u8> = std::iter::repeat(0_u8).take(8).collect();
+        let nonce: Vec<u8> = vec![0; 8];
         let d = order_bigint() / (height + 1);
         let autolykos_solution = AutolykosSolution {
             miner_pk: sk.public_key().unwrap().public_key.into(),
diff --git a/ergo-chain-types/src/autolykos_pow_scheme.rs b/ergo-chain-types/src/autolykos_pow_scheme.rs
@@ -34,11 +34,11 @@ use crate::Header;
 ///
 /// There are 2 cases to consider:
 ///  - If `exponent >= 3` then `N` is represented by
-///      `(-1^sign) * mantissa * 256^(exponent-3)`
+///    `(-1^sign) * mantissa * 256^(exponent-3)`
 ///    E.g. suppose the compact form is given in hex-format by `0x04123456`. Mantissa is `0x123456`
 ///    and `exponent == 4`. So `N == 0x123456 * 265^1`. Now note that we need exactly 4 bytes to
 ///    represent `N`; 3 bytes for the mantissa and 1 byte for the rest. In base-256:
-///      `N == B(0x12)B(0x34)B(0x56)0`
+///    `N == B(0x12)B(0x34)B(0x56)0`
 ///    where `B(y)` denotes the base-256 representation of a hex-number `y` (note how each base-256
 ///    digit is represented by a single-byte).
 ///  - If `exponent < 3` then `N` is represented by the `exponent`-most-significant-bytes of the
@@ -507,8 +507,8 @@ mod tests {
             } else if a.is_zero() || b.is_zero() {
                 return false;
             }
-            let (exp_a, mantissa_a) = a.iter_u32_digits().enumerate().last().unwrap();
-            let (exp_b, mantissa_b) = a.iter_u32_digits().enumerate().last().unwrap();
+            let (exp_a, mantissa_a) = a.iter_u32_digits().enumerate().next_back().unwrap();
+            let (exp_b, mantissa_b) = a.iter_u32_digits().enumerate().next_back().unwrap();
             mantissa_a == mantissa_b && exp_a == exp_b && a.sign() == b.sign()
         }
 
diff --git a/ergo-lib/src/wallet/derivation_path.rs b/ergo-lib/src/wallet/derivation_path.rs
@@ -191,7 +191,7 @@ impl DerivationPath {
     /// Returns an empty path error if the path is empty (master node for example)
     pub fn next(&self) -> Result<DerivationPath, DerivationPathError> {
         #[allow(clippy::unwrap_used)]
-        if self.0.len() > 0 {
+        if !self.0.is_empty() {
             let mut new_path = self.0.to_vec();
             let last_idx = new_path.len() - 1;
             // The bounds have been checked, there is at least one element
diff --git a/ergo-merkle-tree/src/merkleproof.rs b/ergo-merkle-tree/src/merkleproof.rs
@@ -29,7 +29,6 @@ impl std::convert::TryFrom<u8> for NodeSide {
 }
 
 /// A LevelNode used for MerkleProof verification, consists of a 32 byte hash and side it is on in tree
-
 #[cfg_attr(feature = "json", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(
     feature = "json",
diff --git a/ergo-merkle-tree/src/merkletree.rs b/ergo-merkle-tree/src/merkletree.rs
@@ -196,7 +196,10 @@ impl MerkleTree {
         // prepend leaf nodes with empty nodes to build the full tree
         tree_nodes.splice(
             0..0,
-            std::iter::repeat(MerkleNode::empty()).take(tree_nodes.len().next_power_of_two() - 1),
+            std::iter::repeat_n(
+                MerkleNode::empty(),
+                tree_nodes.len().next_power_of_two() - 1,
+            ),
         );
         build_nodes(&mut tree_nodes);
         let nodes_len = tree_nodes.len();
diff --git a/ergo-nipopow/src/nipopow_algos.rs b/ergo-nipopow/src/nipopow_algos.rs
@@ -247,7 +247,7 @@ impl NipopowAlgos {
                 .try_into()
                 .map_err(|_| "Expected 32 byte BlockId")?;
             let block_id = BlockId(Digest32::from(block_id_bytes));
-            res.extend(std::iter::repeat(block_id).take(qty as usize));
+            res.extend(std::iter::repeat_n(block_id, qty as usize));
         }
         Ok(res)
     }
@@ -275,11 +275,11 @@ impl NipopowAlgos {
                                 .iter()
                                 .cloned(),
                         )
-                        .chain(std::iter::repeat(prev_header.id).take(prev_level))
+                        .chain(std::iter::repeat_n(prev_header.id, prev_level))
                         .collect())
                 } else {
                     Ok(std::iter::once(genesis)
-                        .chain(std::iter::repeat(prev_header.id).take(prev_level))
+                        .chain(std::iter::repeat_n(prev_header.id, prev_level))
                         .collect())
                 }
             } else {
diff --git a/ergoscript-compiler/src/parser.rs b/ergoscript-compiler/src/parser.rs
@@ -95,7 +95,7 @@ impl<'t, 'input> Parser<'t, 'input> {
     }
 
     fn at_set(&mut self, set: &[TokenKind]) -> bool {
-        self.peek().map_or(false, |k| set.contains(&k))
+        self.peek().is_some_and(|k| set.contains(&k))
     }
 
     fn at_end(&mut self) -> bool {
diff --git a/ergoscript-compiler/src/parser/source.rs b/ergoscript-compiler/src/parser/source.rs
@@ -39,7 +39,7 @@ impl<'t, 'input> Source<'t, 'input> {
     }
 
     fn at_trivia(&self) -> bool {
-        self.peek_kind_raw().map_or(false, TokenKind::is_trivia)
+        self.peek_kind_raw().is_some_and(TokenKind::is_trivia)
     }
 
     pub fn last_token_range(&self) -> Option<TextRange> {
diff --git a/ergotree-ir/src/chain/address.rs b/ergotree-ir/src/chain/address.rs
@@ -163,7 +163,7 @@ impl Address {
                                                 .map(Address::P2SH)
                                                 .map_err(|_| {
                                                     AddressError::UnexpectedErgoTree(
-                                                        tree.clone(),
+                                                        tree.clone().into(),
                                                         String::from("Failed to create P2SH address, invalid script hash."),
                                                     )
                                                 });
@@ -318,7 +318,7 @@ impl From<NetworkAddress> for String {
 pub enum AddressError {
     /// Unexpected ErgoTree encountered
     #[error("Unexpected ErgoTree: {0:?}, \n reason: {1}")]
-    UnexpectedErgoTree(ErgoTree, String),
+    UnexpectedErgoTree(Box<ErgoTree>, String),
     /// ErgoTree parsing error
     #[error("ErgoTree error: {0}")]
     ErgoTreeError(#[from] ErgoTreeError),
diff --git a/gf2_192/src/gf2_192.rs b/gf2_192/src/gf2_192.rs
@@ -702,7 +702,7 @@ mod tests {
 
         #[allow(clippy::needless_range_loop)]
         fn mul_bits(a: &[i64], b: &[i64]) -> GF2Slow {
-            let mut c: Vec<_> = core::iter::repeat(0).take(a.len() + b.len()).collect();
+            let mut c: Vec<_> = vec![0; a.len() + b.len()];
 
             for i in 0..a.len() {
                 for i1 in 0..64 {
@@ -741,7 +741,7 @@ mod tests {
     impl Modulus {
         fn new(sparse_modulus: &[i32]) -> Modulus {
             let degree = sparse_modulus[0];
-            let mut offset: Vec<_> = core::iter::repeat(0).take(sparse_modulus.len()).collect();
+            let mut offset: Vec<_> = vec![0; sparse_modulus.len()];
             for i in 1..sparse_modulus.len() {
                 offset[i] = degree - sparse_modulus[i];
             }
@@ -754,7 +754,7 @@ mod tests {
     static PENTANOMIAL: [i32; 5] = [192, 7, 2, 1, 0];
 
     fn generate_test_values() -> Vec<Gf2_192> {
-        let mut test_values: Vec<[i64; 3]> = core::iter::repeat([0, 0, 0]).take(250).collect();
+        let mut test_values: Vec<[i64; 3]> = vec![[0, 0, 0]; 250];
         let mut rng = thread_rng();
 
         // Test single 1s in every bit position but last
diff --git a/gf2_192/src/gf2_192poly.rs b/gf2_192/src/gf2_192poly.rs
@@ -227,7 +227,7 @@ mod tests {
         let mut rng = thread_rng();
 
         for len in 1..100 {
-            let mut points: Vec<_> = core::iter::repeat(0).take(len).collect();
+            let mut points: Vec<_> = vec![0; len];
             // Generate a byte that's not an element of `points` nor 0
             let mut j = 0;
             while j < points.len() {
diff --git a/rust-toolchain b/rust-toolchain
@@ -1 +1 @@
-1.83
+1.87

Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ fn prove_block(`
`142`	`142`	`// Ergo test suite uses randomly generated value for ad_proofs_root.`
`143`	`143`	`let mut rng = thread_rng();`
`144`	`144`	`let how_many: usize = rng.gen_range(0..5000);`
`145`		`- let mut ad_proofs_bytes: Vec<u8> = std::iter::repeat(0_u8).take(how_many).collect();`
	`145`	`+ let mut ad_proofs_bytes: Vec<u8> = vec![0; how_many];`
`146`	`146`	`for x in &mut ad_proofs_bytes {`
`147`	`147`	`*x = rng.gen();`
`148`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,6 @@ impl std::convert::TryFrom<u8> for NodeSide {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/// A LevelNode used for MerkleProof verification, consists of a 32 byte hash and side it is on in tree`
`32`		`-`
`33`	`32`	`#[cfg_attr(feature = "json", derive(serde::Serialize, serde::Deserialize))]`
`34`	`33`	`#[cfg_attr(`
`35`	`34`	`feature = "json",`