chore: merge latest agglayer & fix clippy errors

partylikeits1983 · partylikeits1983 · commit 4c3fad983b06 · 2026-03-23T12:25:43.000+03:00
diff --git a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
@@ -221,6 +221,7 @@ fn core_benchmarks(c: &mut Criterion) {
                             .await
                             .expect("execution of the CLAIM note (L1) consumption tx failed"),
                     ))
+                    .await
                 },
                 BatchSize::SmallInput,
             );
@@ -245,6 +246,7 @@ fn core_benchmarks(c: &mut Criterion) {
                             .await
                             .expect("execution of the CLAIM note (L2) consumption tx failed"),
                     ))
+                    .await
                 },
                 BatchSize::SmallInput,
             );
@@ -269,6 +271,7 @@ fn core_benchmarks(c: &mut Criterion) {
                             .await
                             .expect("execution of the B2AGG note consumption tx failed"),
                     ))
+                    .await
                 },
                 BatchSize::SmallInput,
             );
diff --git a/crates/miden-agglayer/src/eth_types/eth_address.rs b/crates/miden-agglayer/src/eth_types/eth_address.rs
@@ -55,7 +55,7 @@ impl EthAddress {
         let prefixed_hex = if hex_str.starts_with("0x") {
             hex_str.to_string()
         } else {
-            format!("0x{}", hex_str)
+            format!("0x{hex_str}")
         };
 
         let bytes: [u8; 20] = hex_to_bytes(&prefixed_hex)?;
@@ -138,7 +138,7 @@ impl fmt::Display for AddressConversionError {
             AddressConversionError::InvalidHexLength => {
                 write!(f, "invalid hex length (expected 40 hex chars)")
             },
-            AddressConversionError::InvalidHexChar(c) => write!(f, "invalid hex character: {}", c),
+            AddressConversionError::InvalidHexChar(c) => write!(f, "invalid hex character: {c}"),
             AddressConversionError::HexParseError => write!(f, "hex parse error"),
             AddressConversionError::FeltOutOfField => {
                 write!(f, "packed 64-bit word does not fit in the field")
diff --git a/crates/miden-protocol/src/account/component/storage/schema/parse.rs b/crates/miden-protocol/src/account/component/storage/schema/parse.rs
@@ -47,7 +47,7 @@ fn parse_simple_word_value(
             SCHEMA_TYPE_REGISTRY.try_parse_word(schema_type, value).map_err(|err| {
                 ComponentMetadataError::InvalidInitStorageValue(
                     slot_prefix.clone(),
-                    format!("failed to parse value as `{}`: {err}", schema_type),
+                    format!("failed to parse value as `{schema_type}`: {err}"),
                 )
             })
         },
diff --git a/crates/miden-protocol/src/account/component/storage/schema/word.rs b/crates/miden-protocol/src/account/component/storage/schema/word.rs
@@ -210,7 +210,7 @@ impl WordSchema {
                 SCHEMA_TYPE_REGISTRY.validate_word_value(r#type, word).map_err(|err| {
                     ComponentMetadataError::InvalidInitStorageValue(
                         slot_prefix.clone(),
-                        format!("{label} does not match `{}`: {err}", r#type),
+                        format!("{label} does not match `{type}`: {err}"),
                     )
                 })
             },
diff --git a/crates/miden-protocol/src/account/component/storage/type_registry.rs b/crates/miden-protocol/src/account/component/storage/type_registry.rs
@@ -364,7 +364,7 @@ impl FeltType for u8 {
 
     fn display_felt(value: Felt) -> Result<String, SchemaTypeError> {
         let native = u8::try_from(value.as_canonical_u64()).map_err(|_| {
-            SchemaTypeError::ConversionError(format!("value `{}` is out of range for u8", value))
+            SchemaTypeError::ConversionError(format!("value `{value}` is out of range for u8"))
         })?;
         Ok(native.to_string())
     }
@@ -391,8 +391,7 @@ impl FeltType for AuthScheme {
     fn display_felt(value: Felt) -> Result<String, SchemaTypeError> {
         let scheme_id = u8::try_from(value.as_canonical_u64()).map_err(|_| {
             SchemaTypeError::ConversionError(format!(
-                "value `{}` is out of range for auth scheme id",
-                value
+                "value `{value}` is out of range for auth scheme id"
             ))
         })?;
 
@@ -418,7 +417,7 @@ impl FeltType for u16 {
 
     fn display_felt(value: Felt) -> Result<String, SchemaTypeError> {
         let native = u16::try_from(value.as_canonical_u64()).map_err(|_| {
-            SchemaTypeError::ConversionError(format!("value `{}` is out of range for u16", value))
+            SchemaTypeError::ConversionError(format!("value `{value}` is out of range for u16"))
         })?;
         Ok(native.to_string())
     }
@@ -438,7 +437,7 @@ impl FeltType for u32 {
 
     fn display_felt(value: Felt) -> Result<String, SchemaTypeError> {
         let native = u32::try_from(value.as_canonical_u64()).map_err(|_| {
-            SchemaTypeError::ConversionError(format!("value `{}` is out of range for u32", value))
+            SchemaTypeError::ConversionError(format!("value `{value}` is out of range for u32"))
         })?;
         Ok(native.to_string())
     }
@@ -504,7 +503,7 @@ fn pad_hex_string(input: &str) -> String {
         // 66 = "0x" + 64 hex chars
         let hex_part = &input[2..];
         let padding = "0".repeat(64 - hex_part.len());
-        format!("0x{}{}", padding, hex_part)
+        format!("0x{padding}{hex_part}")
     } else {
         input.to_string()
     }
diff --git a/crates/miden-protocol/src/account/delta/mod.rs b/crates/miden-protocol/src/account/delta/mod.rs
@@ -420,7 +420,7 @@ impl SequentialCommit for AccountDelta {
         self.storage.append_delta_elements(&mut elements);
 
         debug_assert!(
-            elements.len() % (2 * crate::WORD_SIZE) == 0,
+            elements.len().is_multiple_of(2 * crate::WORD_SIZE),
             "expected elements to contain an even number of words, but it contained {} elements",
             elements.len()
         );
diff --git a/crates/miden-protocol/src/account/storage/header.rs b/crates/miden-protocol/src/account/storage/header.rs
@@ -180,7 +180,7 @@ impl AccountStorageHeader {
 
             // Retrieve slot name from the map.
             let slot_name = slot_names.get(&parsed_slot_id).cloned().ok_or(AccountError::other(
-                format!("slot name not found for slot ID {}", parsed_slot_id),
+                format!("slot name not found for slot ID {parsed_slot_id}"),
             ))?;
 
             // Parse slot value from last 4 elements.
diff --git a/crates/miden-protocol/src/address/routing_parameters.rs b/crates/miden-protocol/src/address/routing_parameters.rs
@@ -294,7 +294,7 @@ fn decode_receiver_profile(
         ABSENT_NOTE_TAG_LEN => None,
         0..=32 => Some(tag_len),
         _ => {
-            return Err(AddressError::decode_error(format!("invalid note tag length {}", tag_len)));
+            return Err(AddressError::decode_error(format!("invalid note tag length {tag_len}")));
         },
     };
 
@@ -355,8 +355,7 @@ fn decode_encryption_key(
         },
         other => {
             return Err(AddressError::decode_error(format!(
-                "unknown encryption key variant: {}",
-                other
+                "unknown encryption key variant: {other}"
             )));
         },
     };
@@ -369,8 +368,7 @@ fn read_x25519_pub_key(
 ) -> Result<eddsa_25519_sha512::PublicKey, AddressError> {
     if byte_iter.len() < X25519_PUBLIC_KEY_LENGTH {
         return Err(AddressError::decode_error(format!(
-            "expected {} bytes to decode X25519 public key",
-            X25519_PUBLIC_KEY_LENGTH
+            "expected {X25519_PUBLIC_KEY_LENGTH} bytes to decode X25519 public key"
         )));
     }
     let key_bytes: [u8; X25519_PUBLIC_KEY_LENGTH] = read_byte_array(byte_iter);
@@ -384,8 +382,7 @@ fn read_k256_pub_key(
 ) -> Result<ecdsa_k256_keccak::PublicKey, AddressError> {
     if byte_iter.len() < K256_PUBLIC_KEY_LENGTH {
         return Err(AddressError::decode_error(format!(
-            "expected {} bytes to decode K256 public key",
-            K256_PUBLIC_KEY_LENGTH
+            "expected {K256_PUBLIC_KEY_LENGTH} bytes to decode K256 public key"
         )));
     }
     let key_bytes: [u8; K256_PUBLIC_KEY_LENGTH] = read_byte_array(byte_iter);
diff --git a/crates/miden-protocol/src/asset/token_symbol.rs b/crates/miden-protocol/src/asset/token_symbol.rs
@@ -270,7 +270,7 @@ mod test {
         for symbol in symbols {
             let from_new = TokenSymbol::new(symbol).unwrap();
             let from_static = TokenSymbol::new_unchecked(symbol);
-            assert_eq!(from_new, from_static, "Mismatch for symbol: {}", symbol);
+            assert_eq!(from_new, from_static, "Mismatch for symbol: {symbol}");
         }
     }
 
diff --git a/crates/miden-standards/src/code_builder/mod.rs b/crates/miden-standards/src/code_builder/mod.rs
@@ -687,11 +687,11 @@ mod tests {
         let static_lib = temp_assembler
             .clone()
             .assemble_library([NamedSource::new("contracts::static_contract", account_code_1)])
-            .map_err(|e| anyhow::anyhow!("failed to assemble static library: {}", e))?;
+            .map_err(|e| anyhow::anyhow!("failed to assemble static library: {e}"))?;
 
         let dynamic_lib = temp_assembler
             .assemble_library([NamedSource::new("contracts::dynamic_contract", account_code_2)])
-            .map_err(|e| anyhow::anyhow!("failed to assemble dynamic library: {}", e))?;
+            .map_err(|e| anyhow::anyhow!("failed to assemble dynamic library: {e}"))?;
 
         // Test linking both static and dynamic libraries
         let builder = CodeBuilder::default()
diff --git a/crates/miden-testing/src/kernel_tests/tx/test_account_interface.rs b/crates/miden-testing/src/kernel_tests/tx/test_account_interface.rs
@@ -702,7 +702,7 @@ async fn test_check_note_consumability_static_analysis_receiver(
         )
         .await;
 
-    assert_eq!(format!("{:?}", consumption_check_result), expected);
+    assert_eq!(format!("{consumption_check_result:?}"), expected);
 
     Ok(())
 }
@@ -792,7 +792,7 @@ async fn test_check_note_consumability_static_analysis_sender(
         )
         .await;
 
-    assert_eq!(format!("{:?}", consumption_check_result), expected);
+    assert_eq!(format!("{consumption_check_result:?}"), expected);
 
     Ok(())
 }
diff --git a/crates/miden-testing/src/kernel_tests/tx/test_note.rs b/crates/miden-testing/src/kernel_tests/tx/test_note.rs
@@ -367,7 +367,7 @@ async fn test_build_metadata_header() -> anyhow::Result<()> {
 
     let sender = tx_context.account().id();
     let receiver = AccountId::try_from(ACCOUNT_ID_REGULAR_PRIVATE_ACCOUNT_UPDATABLE_CODE)
-        .map_err(|e| anyhow::anyhow!("Failed to convert account ID: {}", e))?;
+        .map_err(|e| anyhow::anyhow!("Failed to convert account ID: {e}"))?;
 
     let test_metadata1 = NoteMetadata::new(sender, NoteType::Private)
         .with_tag(NoteTag::with_account_target(receiver));
diff --git a/crates/miden-testing/src/mock_chain/chain.rs b/crates/miden-testing/src/mock_chain/chain.rs
@@ -337,7 +337,7 @@ impl MockChain {
             let block = self
                 .blocks
                 .get(block_index)
-                .ok_or_else(|| anyhow::anyhow!("block {} not found in chain", block_ref_num))?;
+                .ok_or_else(|| anyhow::anyhow!("block {block_ref_num} not found in chain"))?;
             let block_header = block.header().clone();
             // Exclude the reference block header.
             if block_header.commitment() != reference_block_header.commitment() {
diff --git a/crates/miden-testing/tests/agglayer/asset_conversion.rs b/crates/miden-testing/tests/agglayer/asset_conversion.rs
@@ -33,12 +33,11 @@ async fn test_scale_up_helper(
         use agglayer::common::asset_conversion
         
         begin
-            push.{}.{}
+            push.{scale_exponent}.{miden_amount}
             exec.asset_conversion::scale_native_amount_to_u256
             exec.sys::truncate_stack
         end
         ",
-        scale_exponent, miden_amount,
     );
 
     let exec_output = execute_masm_script(&script_code).await?;
diff --git a/crates/miden-testing/tests/agglayer/mmr_frontier.rs b/crates/miden-testing/tests/agglayer/mmr_frontier.rs
@@ -77,7 +77,7 @@ async fn test_append_and_update_frontier() -> anyhow::Result<()> {
 
     for round in 0..32 {
         // construct the leaf from the hex representation of the round number
-        let leaf = Keccak256Digest::try_from(format!("{:#066x}", round).as_str()).unwrap();
+        let leaf = Keccak256Digest::try_from(format!("{round:#066x}").as_str()).unwrap();
         let root = mmr_frontier.append_and_update_frontier(leaf);
         let num_leaves = mmr_frontier.num_leaves;
 
@@ -153,8 +153,7 @@ fn test_solidity_canonical_zeros_compatibility() {
 
         assert_eq!(
             actual, expected,
-            "canonical zero mismatch at height {}: expected {}, got {:?}",
-            height, expected_hex, actual
+            "canonical zero mismatch at height {height}: expected {expected_hex}, got {actual:?}"
         );
     }
 }
diff --git a/crates/miden-testing/tests/agglayer/solidity_miden_address_conversion.rs b/crates/miden-testing/tests/agglayer/solidity_miden_address_conversion.rs
@@ -121,7 +121,7 @@ async fn test_ethereum_address_to_account_id_in_masm() -> anyhow::Result<()> {
             .iter()
             .map(|f| {
                 let val = f.as_canonical_u64();
-                assert!(val <= u32::MAX as u64, "felt value {} exceeds u32::MAX", val);
+                assert!(val <= u32::MAX as u64, "felt value {val} exceeds u32::MAX");
                 val as u32
             })
             .collect();
@@ -132,7 +132,7 @@ async fn test_ethereum_address_to_account_id_in_masm() -> anyhow::Result<()> {
         let limb3 = limbs[3];
         let limb4 = limbs[4];
 
-        assert_eq!(limb0, 0, "test {}: expected msb limb (limb0) to be zero", idx);
+        assert_eq!(limb0, 0, "test {idx}: expected msb limb (limb0) to be zero");
 
         let account_id_felts: [Felt; 2] = (*original_account_id).into();
         let expected_prefix = account_id_felts[0];
@@ -144,12 +144,11 @@ async fn test_ethereum_address_to_account_id_in_masm() -> anyhow::Result<()> {
             use agglayer::common::eth_address
 
             begin
-                push.{}.{}.{}.{}.{}
+                push.{limb4}.{limb3}.{limb2}.{limb1}.{limb0}
                 exec.eth_address::to_account_id
                 exec.sys::truncate_stack
             end
-            "#,
-            limb4, limb3, limb2, limb1, limb0
+            "#
         );
 
         let program = Assembler::new(Arc::new(DefaultSourceManager::default()))
@@ -165,15 +164,14 @@ async fn test_ethereum_address_to_account_id_in_masm() -> anyhow::Result<()> {
         let actual_suffix = exec_output.stack[0];
         let actual_prefix = exec_output.stack[1];
 
-        assert_eq!(actual_prefix, expected_prefix, "test {}: prefix mismatch", idx);
-        assert_eq!(actual_suffix, expected_suffix, "test {}: suffix mismatch", idx);
+        assert_eq!(actual_prefix, expected_prefix, "test {idx}: prefix mismatch");
+        assert_eq!(actual_suffix, expected_suffix, "test {idx}: suffix mismatch");
 
         let reconstructed_account_id = AccountId::try_from_elements(actual_suffix, actual_prefix)?;
 
         assert_eq!(
             reconstructed_account_id, *original_account_id,
-            "test {}: accountId roundtrip failed",
-            idx
+            "test {idx}: accountId roundtrip failed"
         );
     }
 
diff --git a/crates/miden-testing/tests/agglayer/test_utils.rs b/crates/miden-testing/tests/agglayer/test_utils.rs
@@ -78,8 +78,6 @@ pub async fn assert_execution_fails_with(script_code: &str, expected_error: &str
     let error_msg = result.unwrap_err().to_string();
     assert!(
         error_msg.contains(expected_error),
-        "Expected error containing '{}', got: {}",
-        expected_error,
-        error_msg
+        "Expected error containing '{expected_error}', got: {error_msg}"
     );
 }
diff --git a/crates/miden-testing/tests/agglayer/update_ger.rs b/crates/miden-testing/tests/agglayer/update_ger.rs
@@ -132,8 +132,7 @@ async fn compute_ger() -> anyhow::Result<()> {
 
         assert_eq!(
             computed_ger_felts, expected_ger_felts,
-            "Computed GER mismatch for test vector {}",
-            i
+            "Computed GER mismatch for test vector {i}"
         );
 
         // Convert exit roots to packed u32 felts for memory initialization
@@ -178,7 +177,7 @@ async fn compute_ger() -> anyhow::Result<()> {
 
         let result_digest: Vec<Felt> = exec_output.stack[0..8].to_vec();
 
-        assert_eq!(result_digest, expected_ger_felts, "GER mismatch for test vector {}", i);
+        assert_eq!(result_digest, expected_ger_felts, "GER mismatch for test vector {i}");
     }
 
     Ok(())
diff --git a/crates/miden-testing/tests/auth/hybrid_multisig.rs b/crates/miden-testing/tests/auth/hybrid_multisig.rs
diff --git a/crates/miden-testing/tests/auth/multisig.rs b/crates/miden-testing/tests/auth/multisig.rs
diff --git a/crates/miden-tx/src/host/mod.rs b/crates/miden-tx/src/host/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ fn parse_simple_word_value(`
`47`	`47`	`SCHEMA_TYPE_REGISTRY.try_parse_word(schema_type, value).map_err(\|err\| {`
`48`	`48`	`ComponentMetadataError::InvalidInitStorageValue(`
`49`	`49`	`slot_prefix.clone(),`
`50`		- format!("failed to parse value as `{}`: {err}", schema_type),
	`50`	+ format!("failed to parse value as `{schema_type}`: {err}"),
`51`	`51`	`)`
`52`	`52`	`})`
`53`	`53`	`},`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ impl WordSchema {`
`210`	`210`	`SCHEMA_TYPE_REGISTRY.validate_word_value(r#type, word).map_err(\|err\| {`
`211`	`211`	`ComponentMetadataError::InvalidInitStorageValue(`
`212`	`212`	`slot_prefix.clone(),`
`213`		- format!("{label} does not match `{}`: {err}", r#type),
	`213`	+ format!("{label} does not match `{type}`: {err}"),
`214`	`214`	`)`
`215`	`215`	`})`
`216`	`216`	`},`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ mod test {`
`270`	`270`	`for symbol in symbols {`
`271`	`271`	`let from_new = TokenSymbol::new(symbol).unwrap();`
`272`	`272`	`let from_static = TokenSymbol::new_unchecked(symbol);`
`273`		`- assert_eq!(from_new, from_static, "Mismatch for symbol: {}", symbol);`
	`273`	`+ assert_eq!(from_new, from_static, "Mismatch for symbol: {symbol}");`
`274`	`274`	`}`
`275`	`275`	`}`
`276`	`276`