chore: update rust to 1.86 (#1759)

* chore: update rust to 1.86

* chore: simplify get_output_account (#1760)

---------

Co-authored-by: ananas-block <58553958+ananas-block@users.noreply.github.com>

Author: sergeytimoshin

.github/workflows/lint.yml

@@ -37,5 +37,5 @@ jobs:
           rustup target add x86_64-unknown-linux-gnu --toolchain nightly
           rustup component add --toolchain nightly rustfmt
           rustup component add --toolchain nightly clippy
-          rustup component add --toolchain 1.83-x86_64-unknown-linux-gnu clippy
+          rustup component add --toolchain 1.86-x86_64-unknown-linux-gnu clippy
           ./scripts/lint.sh

examples/anchor/counter/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(unexpected_cfgs)]
+
 use anchor_lang::{prelude::*, AnchorDeserialize, Discriminator};
 use light_sdk::{
     account::LightAccount,

forester/src/epoch_manager.rs

@@ -314,7 +314,7 @@ impl<R: RpcConnection, I: Indexer + IndexerType<R> + 'static> EpochManager<R, I>
                 "last_epoch: {:?}, current_epoch: {:?}, slot: {:?}",
                 last_epoch, current_epoch, slot
             );
-            if last_epoch.map_or(true, |last| current_epoch > last) {
+            if last_epoch.is_none_or(|last| current_epoch > last) {
                 debug!("New epoch detected: {}", current_epoch);
                 let phases = get_epoch_phases(&self.protocol_config, current_epoch);
                 if slot < phases.registration.end {

forester/src/smart_transaction.rs

@@ -32,8 +32,8 @@ pub struct CreateSmartTransactionConfig {
 ///
 /// # Returns
 /// The confirmed transaction signature or an error if the confirmation times out
-pub async fn poll_transaction_confirmation<'a, R: RpcConnection>(
-    connection: &mut bb8::PooledConnection<'a, SolanaConnectionManager<R>>,
+pub async fn poll_transaction_confirmation<R: RpcConnection>(
+    connection: &mut bb8::PooledConnection<'_, SolanaConnectionManager<R>>,
     txt_sig: Signature,
     abort_timeout: Duration,
 ) -> Result<Signature, light_client::rpc::RpcError> {
@@ -80,8 +80,8 @@ pub async fn poll_transaction_confirmation<'a, R: RpcConnection>(
 }
 
 // Sends a transaction and handles its confirmation. Retries until timeout or last_valid_block_height is reached.
-pub async fn send_and_confirm_transaction<'a, R: RpcConnection>(
-    connection: &mut bb8::PooledConnection<'a, SolanaConnectionManager<R>>,
+pub async fn send_and_confirm_transaction<R: RpcConnection>(
+    connection: &mut bb8::PooledConnection<'_, SolanaConnectionManager<R>>,
     transaction: &Transaction,
     send_transaction_config: RpcSendTransactionConfig,
     last_valid_block_height: u64,
@@ -118,7 +118,7 @@ pub async fn send_and_confirm_transaction<'a, R: RpcConnection>(
 ///
 /// # Arguments
 /// * `config` - The configuration for the smart transaction, which includes the transaction's instructions, signers, and lookup tables, depending on
-///     whether it's a legacy or versioned smart transaction. The transaction's send configuration can also be changed, if provided
+///   whether it's a legacy or versioned smart transaction. The transaction's send configuration can also be changed, if provided
 ///
 /// # Returns
 /// An optimized `Transaction` and the `last_valid_block_height`

program-libs/batched-merkle-tree/src/merkle_tree.rs

@@ -356,22 +356,22 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     /// Update the tree from the output queue account.
     /// 1. Create public inputs hash.
     /// 2. Verify update proof and update tree account.
-    ///     2.1. Verify proof.
-    ///     2.2. Increment sequence number.
-    ///     2.3. Increment next index.
-    ///     2.4. Append new root to root history.
+    ///    2.1. Verify proof.
+    ///    2.2. Increment sequence number.
+    ///    2.3. Increment next index.
+    ///    2.4. Append new root to root history.
     /// 3. Mark zkp batch as inserted in the merkle tree.
-    ///     3.1. Checks that the batch is ready.
-    ///     3.2. Increment the number of inserted zkps.
-    ///     3.3. If all zkps are inserted, set batch state to inserted.
+    ///    3.1. Checks that the batch is ready.
+    ///    3.2. Increment the number of inserted zkps.
+    ///    3.3. If all zkps are inserted, set batch state to inserted.
     /// 4. Increment next full batch index if inserted.
     /// 5. Zero out previous batch bloom filter of input queue
-    ///     if current batch is 50% inserted.
+    ///    if current batch is 50% inserted.
     /// 6. Return the batch append event.
     ///
     /// Note: when proving inclusion by index in
-    ///     value array we need to insert the value into a bloom_filter once it is
-    ///     inserted into the tree. Check this with get_num_inserted_zkps
+    /// value array we need to insert the value into a bloom_filter once it is
+    /// inserted into the tree. Check this with get_num_inserted_zkps
     pub fn update_tree_from_output_queue_account(
         &mut self,
         queue_account: &mut BatchedQueueAccount,
@@ -475,14 +475,14 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     /// Update the tree from the input/address queue account.
     /// 1. Create public inputs hash.
     /// 2. Verify update proof and update tree account.
-    ///     2.1. Verify proof.
-    ///     2.2. Increment sequence number.
-    ///     2.3. If address tree increment next index.
-    ///     2.4. Append new root to root history.
+    ///    2.1. Verify proof.
+    ///    2.2. Increment sequence number.
+    ///    2.3. If address tree increment next index.
+    ///    2.4. Append new root to root history.
     /// 3. Mark batch as inserted in the merkle tree.
-    ///     3.1. Checks that the batch is ready.
-    ///     3.2. Increment the number of inserted zkps.
-    ///     3.3. If all zkps are inserted, set the state to inserted.
+    ///    3.1. Checks that the batch is ready.
+    ///    3.2. Increment the number of inserted zkps.
+    ///    3.3. If all zkps are inserted, set the state to inserted.
     /// 4. Zero out previous batch bloom filter if current batch is 50% inserted.
     /// 5. Increment next full batch index if inserted.
     /// 6. Return the batch nullify event.
@@ -618,13 +618,13 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     /// 1. Check that the tree is a state tree.
     /// 2. Create nullifier Hash(value,leaf_index, tx_hash).
     /// 3. Insert nullifier into current batch.
-    ///     3.1. Insert compressed_account_hash into bloom filter.
-    ///         (bloom filter enables non-inclusion proofs in later txs)
-    ///     3.2. Add nullifier to leaves hash chain.
-    ///         (Nullification means, the compressed_account_hash in the tree,
-    ///         is overwritten with a nullifier hash)
-    ///     3.3. Check that compressed_account_hash
-    ///         does not exist in any other bloom filter.
+    ///    3.1. Insert compressed_account_hash into bloom filter.
+    ///    (bloom filter enables non-inclusion proofs in later txs)
+    ///    3.2. Add nullifier to leaves hash chain.
+    ///    (Nullification means, the compressed_account_hash in the tree,
+    ///    is overwritten with a nullifier hash)
+    ///    3.3. Check that compressed_account_hash
+    ///    does not exist in any other bloom filter.
     pub fn insert_nullifier_into_queue(
         &mut self,
         compressed_account_hash: &[u8; 32],
@@ -707,8 +707,8 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     /// Steps:
     /// 1. Check whether overlapping roots exist.
     /// 2. If yes:
-    ///     2.1. Get, first safe root index.
-    ///     2.2. Zero out roots from the oldest root to first safe root.
+    ///    2.1. Get, first safe root index.
+    ///    2.2. Zero out roots from the oldest root to first safe root.
     ///
     /// Note on security for root buffer:
     /// Account {
@@ -722,20 +722,20 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     /// Timeslot 1:
     /// - insert into B1 until full
     /// - update tree with B0 in 4 partial updates, don't clear B0 yet
-    ///     -> R0 -> B0.1
-    ///     -> R1 -> B0.2
-    ///     -> R2 -> B0.3
-    ///     -> R3 -> B0.4 - final B0 root
-    ///     B0.sequence_number = 13 (3 + account.root.length)
-    ///     B0.root_index = 3
+    ///   -> R0 -> B0.1
+    ///   -> R1 -> B0.2
+    ///   -> R2 -> B0.3
+    ///   -> R3 -> B0.4 - final B0 root
+    ///   B0.sequence_number = 13 (3 + account.root.length)
+    ///   B0.root_index = 3
     /// - execute some B1 root updates
-    ///     -> R4 -> B1.1
-    ///     -> R5 -> B1.2
-    ///     -> R6 -> B1.3
-    ///     -> R7 -> B1.4 - final B1 (update batch 0) root
-    ///     B0.sequence_number = 17 (7 + account.root.length)
-    ///     B0.root_index = 7
-    ///     current_sequence_number = 8
+    ///   -> R4 -> B1.1
+    ///   -> R5 -> B1.2
+    ///   -> R6 -> B1.3
+    ///   -> R7 -> B1.4 - final B1 (update batch 0) root
+    ///   B0.sequence_number = 17 (7 + account.root.length)
+    ///   B0.root_index = 7
+    ///   current_sequence_number = 8
     ///
     /// Timeslot 2:
     ///     - clear B0
@@ -779,12 +779,12 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     ///
     /// Idea:
     /// 1. Zeroing out the bloom filter of the previous batch is expensive
-    ///     -> the forester should do it.
+    ///    -> the forester should do it.
     /// 2. We don't want to zero out the bloom filter when inserting
-    ///     the last zkp of a batch for this might result in failing user tx.
+    ///    the last zkp of a batch for this might result in failing user tx.
     /// 3. Wait until next batch is 50% full as grace period for clients
-    ///     to switch from proof by index to proof by zkp
-    ///     for values inserted in the previous batch.
+    ///    to switch from proof by index to proof by zkp
+    ///    for values inserted in the previous batch.
     ///
     /// Steps:
     /// 1. Previous batch must be inserted and bloom filter must not be zeroed out.
@@ -794,9 +794,9 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     ///    3.2. zero out bloom filter
     ///    3.3. zero out roots if needed
     ///
-    ///     Initial state: 0 pending -> 1 previous pending even though it was never used
-    ///     0 inserted -> 1 pending 0 -> 1 pending 50% - zero out 0 -> 1 inserted
-    ///     0 pending -> 1 inserted
+    ///   Initial state: 0 pending -> 1 previous pending even though it was never used
+    ///   0 inserted -> 1 pending 0 -> 1 pending 50% - zero out 0 -> 1 inserted
+    ///   0 pending -> 1 inserted
     fn zero_out_previous_batch_bloom_filter(&mut self) -> Result<(), BatchedMerkleTreeError> {
         let current_batch = self.queue_batches.pending_batch_index as usize;
         let batch_size = self.queue_batches.batch_size;
@@ -1101,15 +1101,15 @@ mod test {
     /// 1. No batch is ready -> nothing should happen.
     /// 2. Batch 0 is inserted but Batch 1 is empty -> nothing should happen.
     /// 3. Batch 0 is inserted but Batch 1 is 25% full (not the required half)
-    ///     -> nothing should happen.
+    ///    -> nothing should happen.
     /// 4. Batch 0 is inserted and Batch 1 is full
-    ///     -> should zero out all existing roots except the last one.
+    ///    -> should zero out all existing roots except the last one.
     /// 5. Batch 1 is inserted and Batch 0 is empty
-    ///     -> nothing should happen.
+    ///    -> nothing should happen.
     /// 6. Batch 1 is inserted and Batch 0 is 25% full (not the required half)
-    ///     -> nothing should happen.
+    ///    -> nothing should happen.
     /// 7. Batch 1 is inserted and Batch 0 is half full and no overlapping roots exist
-    ///     -> bloom filter is zeroed, roots are untouched.
+    ///    -> bloom filter is zeroed, roots are untouched.
     /// 8. Batch 1 is already zeroed -> nothing should happen
     /// 9. Batch 1 is inserted and Batch 0 is full and overlapping roots exist
     #[test]

program-libs/batched-merkle-tree/src/queue.rs

@@ -96,17 +96,17 @@ impl BatchedQueueMetadata {
 /// An output queue is configured with:
 /// 1. 2 batches
 /// 2. 2 value vecs (one for each batch)
-///     value vec length = batch size
+///    value vec length = batch size
 /// 3. 2 hash chain vecs (one for each batch)
-///     hash chain store length = batch size /zkp batch size
+///    hash chain store length = batch size /zkp batch size
 ///
 /// Default config:
 /// - 50,000 batch size
 /// - 500 zkp batch size
 ///
 /// Initialization:
 /// - an output queue is initialized
-///     in combination with a state Merkle tree
+///   in combination with a state Merkle tree
 /// - `init_batched_state_merkle_tree_from_account_info`
 ///
 /// For deserialization use:
@@ -121,7 +121,7 @@ impl BatchedQueueMetadata {
 ///
 /// To spend, the account compression program uses:
 /// - check_leaf_index_could_exist_in_batches in combination with
-///     `prove_inclusion_by_index_and_zero_out_leaf`
+///   `prove_inclusion_by_index_and_zero_out_leaf`
 ///
 /// To read, light the system program uses:
 /// - `prove_inclusion_by_index`
@@ -298,8 +298,8 @@ impl<'a> BatchedQueueAccount<'a> {
     /// Proves inclusion of leaf index if it exists in one of the batches.
     /// 1. Iterate over all batches
     /// 2. Check if leaf index could exist in the batch.
-    ///     2.1 If yes, check whether value at index is equal to hash_chain_value.
-    ///         Throw error if not.
+    ///    2.1 If yes, check whether value at index is equal to hash_chain_value.
+    ///    Throw error if not.
     /// 3. Return true if leaf index exists in one of the batches.
     ///
     /// Note, this method does not fail but returns `false`
@@ -448,7 +448,7 @@ impl DerefMut for BatchedQueueAccount<'_> {
 ///
 /// Steps:
 /// 1. Check if the current batch is ready.
-///     1.1. If the current batch is inserted, clear the batch.
+///    1.1. If the current batch is inserted, clear the batch.
 /// 2. Insert value into the current batch.
 /// 3. If batch is full, increment currently_processing_batch_index.
 #[allow(clippy::too_many_arguments)]

program-libs/batched-merkle-tree/src/rollover_address_tree.rs

@@ -45,15 +45,15 @@ pub fn rollover_batched_address_tree_from_account_info(
 ///
 /// Steps:
 /// 1. Check that Merkle tree is ready to be rolled over:
-///     1.1. rollover threshold is configured
-///     1.2. next index is greater than rollover threshold
-///     1.3. the network fee is not set if the current fee is zero
+///    1.1. rollover threshold is configured
+///    1.2. next index is greater than rollover threshold
+///    1.3. the network fee is not set if the current fee is zero
 /// 2. Rollover the old Merkle tree and check:
-///     2.2. Rollover is configured.
-///     2.3. Tree is not already rolled over.
-///     2.4. Mark as rolled over in this slot.
+///    2.2. Rollover is configured.
+///    2.3. Tree is not already rolled over.
+///    2.4. Mark as rolled over in this slot.
 /// 3. Initialize new batched address Merkle tree account
-///     with the same parameters as the old account.
+///    with the same parameters as the old account.
 pub fn rollover_batched_address_tree<'a>(
     old_merkle_tree: &mut BatchedMerkleTreeAccount<'a>,
     new_mt_data: &'a mut [u8],

program-libs/batched-merkle-tree/src/rollover_state_tree.rs

@@ -123,21 +123,21 @@ pub fn rollover_batched_state_tree_from_account_info(
 ///
 /// Steps:
 /// 1. Check that Merkle tree is ready to be rolled over:
-///     1.1. rollover threshold is configured
-///     1.2. next index is greater than rollover threshold
-///     1.3. the network fee is not set if the current fee is zero
+///    1.1. rollover threshold is configured
+///    1.2. next index is greater than rollover threshold
+///    1.3. the network fee is not set if the current fee is zero
 /// 2. Rollover Merkle tree and check:
-///     2.1. Merkle tree and queue are associated.
-///     2.2. Rollover is configured.
-///     2.3. Tree is not already rolled over.
-///     2.4. Mark as rolled over in this slot.
+///    2.1. Merkle tree and queue are associated.
+///    2.2. Rollover is configured.
+///    2.3. Tree is not already rolled over.
+///    2.4. Mark as rolled over in this slot.
 /// 3. Rollover output queue and check:
-///     3.1. Merkle tree and queue are associated.
-///     3.2. Rollover is configured.
-///     3.3. Tree is not already rolled over.
-///     3.4. Mark as rolled over in this slot.
+///    3.1. Merkle tree and queue are associated.
+///    3.2. Rollover is configured.
+///    3.3. Tree is not already rolled over.
+///    3.4. Mark as rolled over in this slot.
 /// 4. Initialize new Merkle tree and output queue
-///     with the same parameters as old accounts.
+///    with the same parameters as old accounts.
 pub fn rollover_batched_state_tree(
     params: RolloverBatchStateTreeParams,
 ) -> Result<(), BatchedMerkleTreeError> {

program-libs/compressed-account/src/indexer_event/parse.rs

@@ -67,10 +67,10 @@ struct AssociatedInstructions<'a> {
 /// 1. light_system_program::{Invoke, InvokeCpi, InvokeCpiReadOnly} (one of the 3)
 /// 2. account_compression::InsertIntoQueues
 /// - We return new addresses in batched trees separately
-///     because from the PublicTransactionEvent there
-///     is no way to know which addresses are new and
-///     for batched address trees we need to index the queue of new addresses
-///     the tree&queue account only contains bloomfilters, roots and metadata.
+///   because from the PublicTransactionEvent there
+///   is no way to know which addresses are new and
+///   for batched address trees we need to index the queue of new addresses
+///   the tree&queue account only contains bloomfilters, roots and metadata.
 ///
 /// Steps:
 /// 0. Wrap program ids of instructions to filter but not change the pattern

program-libs/hasher/src/to_byte_array.rs

@@ -395,7 +395,7 @@ mod test {
         // Test with longer string that gets truncated
         let long_string =
             "this is a string that is longer than 32 bytes and will be fail".to_string();
-        let byte_len = long_string.as_bytes().len();
+        let byte_len = long_string.len();
         let result = long_string.to_byte_array();
         assert_eq!(result, Err(HasherError::InvalidInputLength(31, byte_len)));
     }