@layerzerolabs/protocol-stellar-v2 0.2.122 → 0.2.123

package/endpoint-v2/src/tests/endpoint_v2/pay_messaging_fees.rs

@@ -23,7 +23,13 @@ fn pay_messaging_fees(
     let env = &context.env;
     let endpoint_addr = &context.endpoint_client.address;
     env.as_contract(endpoint_addr, || {
-        EndpointV2::pay_messaging_fees_for_test(env, pay_in_zro, native_fee_recipients, zro_fee_recipients, refund_address)
+        EndpointV2::pay_messaging_fees_for_test(
+            env,
+            pay_in_zro,
+            native_fee_recipients,
+            zro_fee_recipients,
+            refund_address,
+        )
     })
 }
 

package/endpoint-v2/src/tests/endpoint_v2/quote.rs

@@ -304,8 +304,8 @@ fn test_quote_with_large_message() {
 
     // Create a large message (1024 bytes)
     let mut large_message_data = [0u8; 1024];
-    for i in 0..1024 {
-        large_message_data[i] = (i % 256) as u8;
+    for (i, byte) in large_message_data.iter_mut().enumerate() {
+        *byte = (i % 256) as u8;
     }
     let large_message = Bytes::from_array(env, &large_message_data);
 

package/endpoint-v2/src/tests/endpoint_v2/ttl_config.rs

@@ -141,7 +141,10 @@ fn test_freeze_ttl_configs_already_frozen() {
 
     // Try to freeze again
     context.mock_owner_auth("freeze_ttl_configs", ());
-    assert_eq!(endpoint.try_freeze_ttl_configs().unwrap_err().unwrap(), TtlConfigurableError::TtlConfigAlreadyFrozen.into());
+    assert_eq!(
+        endpoint.try_freeze_ttl_configs().unwrap_err().unwrap(),
+        TtlConfigurableError::TtlConfigAlreadyFrozen.into()
+    );
 }
 
 #[test]

package/endpoint-v2/src/tests/endpoint_v2/verifiable.rs

@@ -146,7 +146,6 @@ fn test_verifiable_upper_bound_is_enforced_when_inbound_nonce_nonzero() {
     assert!(!endpoint_client.verifiable(&too_far, &receiver));
 }
 
-
 #[test]
 fn test_verifiable_true_when_payload_hash_exists_even_if_nonce_outside_window() {
     let context = setup();

package/endpoint-v2/src/tests/message_lib_manager/require_receive_lib_for_eid.rs

@@ -11,7 +11,9 @@ fn test_require_receive_lib_for_eid_unregistered_lib() {
     let endpoint_client = &context.endpoint_client;
 
     let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid)
+    });
 }
 
 #[test]
@@ -24,7 +26,9 @@ fn test_require_receive_lib_for_eid_wrong_lib_type() {
     let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid)
+    });
 }
 
 #[test]
@@ -38,7 +42,9 @@ fn test_require_receive_lib_for_eid_unsupported_eid() {
     let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, unsupported_eid)
+    });
 }
 
 #[test]

package/endpoint-v2/src/tests/message_lib_manager/require_send_lib_for_eid.rs

@@ -38,7 +38,9 @@ fn test_require_send_lib_for_eid_unsupported_eid() {
     let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_send_lib_for_eid_for_test(env, &lib, unsupported_eid)
+    });
 }
 
 #[test]
@@ -49,7 +51,9 @@ fn test_require_send_lib_for_eid_success_for_send_and_send_and_receive() {
 
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&send_lib);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &send_lib, context.eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_send_lib_for_eid_for_test(env, &send_lib, context.eid)
+    });
 
     let send_and_receive = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
     context.register_library_with_auth(&send_and_receive);

package/endpoint-v2/src/tests/message_lib_manager/require_supported_eid.rs

@@ -10,7 +10,9 @@ fn test_require_supported_eid_with_supported() {
     let endpoint_client = &context.endpoint_client;
 
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid_for_test(env, &send_lib, context.eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_supported_eid_for_test(env, &send_lib, context.eid)
+    });
 }
 
 // The require_supported_eid rejects when the library does not support the EID
@@ -23,7 +25,9 @@ fn test_require_supported_eid_with_unsupported() {
 
     let unsupported_eid = context.eid + 1;
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid_for_test(env, &send_lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_supported_eid_for_test(env, &send_lib, unsupported_eid)
+    });
 }
 
 // The require_supported_eid panics if the library address has no deployed contract

package/endpoint-v2/src/tests/messaging_channel/clear_payload.rs

@@ -239,10 +239,7 @@ fn test_clear_payload_missing_intermediate_nonce() {
 
     // inbound_nonce should be 1 (nonce 2 is missing), and nonce 3 should be pending.
     assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 1);
-    assert_eq!(
-        endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender),
-        soroban_sdk::vec![env, 3u64]
-    );
+    assert_eq!(endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender), soroban_sdk::vec![env, 3u64]);
 
     // Clearing nonce 1 succeeds.
     clear_payload(&context, &receiver, src_eid, &sender, 1, &payload1);

package/endpoint-v2/src/tests/messaging_channel/inbound.rs

@@ -191,10 +191,7 @@ fn test_inbound_accepts_upper_bound_when_inbound_nonce_nonzero() {
 
     // Nonce 356 is not consecutive to 100, so it stays pending and inbound_nonce does not advance.
     assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 100);
-    assert_eq!(
-        endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender),
-        soroban_sdk::vec![env, 356u64]
-    );
+    assert_eq!(endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender), soroban_sdk::vec![env, 356u64]);
     assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &356u64), Some(hash));
 }
 

package/endpoint-v2/src/tests/messaging_channel/mod.rs

@@ -4,9 +4,9 @@ mod inbound;
 mod inbound_nonce;
 mod inbound_payload_hash;
 mod insert_and_drain_pending_nonces;
-mod pending_inbound_nonces;
 mod next_guid;
 mod nilify;
 mod outbound;
 mod outbound_nonce;
+mod pending_inbound_nonces;
 mod skip;

package/endpoint-v2/src/tests/messaging_channel/nilify.rs

@@ -193,24 +193,15 @@ fn test_nilify_closes_gap_and_drains_pending_nonces() {
     });
 
     assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 1);
-    assert_eq!(
-        endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender),
-        soroban_sdk::vec![env, 3u64]
-    );
+    assert_eq!(endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender), soroban_sdk::vec![env, 3u64]);
 
     // Nilify nonce 2 with None closes the gap and should drain pending to advance inbound nonce to 3.
     nilify_with_auth(&context, &receiver, &receiver, src_eid, &sender, 2u64, &None);
 
     assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 3);
     assert!(endpoint_client.pending_inbound_nonces(&receiver, &src_eid, &sender).is_empty());
-    assert_eq!(
-        endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2u64),
-        Some(nil_hash(&context))
-    );
-    assert_eq!(
-        endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &3u64),
-        Some(payload_hash_3)
-    );
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2u64), Some(nil_hash(&context)));
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &3u64), Some(payload_hash_3));
 }
 
 // Nilify is allowed when nonce <= inbound_nonce if an `inbound_payload_hash` exists

package/endpoint-v2/src/tests/messaging_channel/pending_inbound_nonces.rs

@@ -108,4 +108,3 @@ fn test_pending_inbound_nonces_isolated_by_path() {
     assert_eq!(endpoint_client.pending_inbound_nonces(&receiver_a, &src_eid_b, &sender_a), vec![env, 2u64]);
     assert_eq!(endpoint_client.pending_inbound_nonces(&receiver_a, &src_eid_a, &sender_b), vec![env, 2u64]);
 }
-

package/endpoint-v2/src/tests/messaging_composer/lz_compose_alert.rs

@@ -40,6 +40,7 @@ fn default_fixture(env: &Env) -> LzComposeAlertFixture {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn invoke_lz_compose_alert_with_auth<'a>(
     context: &TestSetup,
     endpoint_client: &EndpointV2Client<'a>,

package/message-libs/uln-302/src/tests/send_uln302/send.rs

@@ -76,8 +76,16 @@ fn test_send_events_emittance() {
         &setup.env,
         &setup.uln302.address,
         &[
-            &ExecutorFeePaid {  guid: packet.guid.clone(),executor: executor.clone(), fee: native_fee_recipients.get(0).unwrap().clone() },
-            &DVNFeePaid { guid: packet.guid.clone(),dvns: dvns.slice(0..2).clone(), fees: native_fee_recipients.slice(1..3).clone() },
+            &ExecutorFeePaid {
+                guid: packet.guid.clone(),
+                executor: executor.clone(),
+                fee: native_fee_recipients.get(0).unwrap().clone(),
+            },
+            &DVNFeePaid {
+                guid: packet.guid.clone(),
+                dvns: dvns.slice(0..2).clone(),
+                fees: native_fee_recipients.slice(1..3).clone(),
+            },
         ],
     );
 
@@ -164,8 +172,16 @@ fn test_send_events_emittance_with_zro() {
         &setup.env,
         &setup.uln302.address,
         &[
-            &ExecutorFeePaid {  guid: packet.guid.clone(), executor: executor.clone(), fee: native_fee_recipients.get(0).unwrap().clone() },
-            &DVNFeePaid { guid: packet.guid.clone(), dvns: dvns.slice(0..2).clone(), fees: native_fee_recipients.slice(1..3).clone() },
+            &ExecutorFeePaid {
+                guid: packet.guid.clone(),
+                executor: executor.clone(),
+                fee: native_fee_recipients.get(0).unwrap().clone(),
+            },
+            &DVNFeePaid {
+                guid: packet.guid.clone(),
+                dvns: dvns.slice(0..2).clone(),
+                fees: native_fee_recipients.slice(1..3).clone(),
+            },
         ],
     );
 

package/message-libs/uln-302/src/tests/uln302/get_app_receive_uln_config.rs

@@ -34,8 +34,8 @@ fn test_get_oapp_receive_uln_config() {
     endpoint.set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
 
     let oapp_config = uln302.oapp_receive_uln_config(&oapp, &eid).unwrap();
-    assert_eq!(oapp_config.use_default_confirmations, true);
-    assert_eq!(oapp_config.use_default_required_dvns, false);
+    assert!(oapp_config.use_default_confirmations);
+    assert!(!oapp_config.use_default_required_dvns);
 }
 
 #[test]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.122",
+  "version": "0.2.123",
   "private": false,
   "license": "LZBL-1.3",
   "files": [
@@ -9,19 +9,18 @@
     "message-libs",
     "upgrader",
     "workers",
-    "docs",
     "Cargo.toml",
     "rust-toolchain.toml",
     "rustfmt.toml",
     "clippy.toml"
   ],
   "dependencies": {
-    "@layerzerolabs/common-utils-stellar-contracts": "0.2.122",
-    "@layerzerolabs/common-utils-macros-stellar-contracts": "0.2.122"
+    "@layerzerolabs/common-utils-macros-stellar-contracts": "0.2.123",
+    "@layerzerolabs/common-utils-stellar-contracts": "0.2.123"
   },
   "devDependencies": {
-    "@layerzerolabs/build-utils-rust": "0.2.122",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.122"
+    "@layerzerolabs/build-utils-rust": "0.2.123",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.123"
   },
   "publishConfig": {
     "access": "public",
@@ -46,8 +45,9 @@
     "build:native": "pnpm build:contracts:native",
     "clean": "rm -rf ./dependencies ./target ./node_modules",
     "format": "pnpm exec lz-tool --script \"cargo fmt\" stellar",
-    "lint": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo clippy -- -D warnings\" stellar",
-    "lint:fix": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo clippy --fix --allow-dirty --allow-staged && cargo fmt\" stellar",
+    "format:check": "pnpm exec lz-tool --script \"cargo fmt -- --check\" stellar",
+    "lint": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo fmt -- --check && cargo clippy --all-targets -- -D warnings\" stellar",
+    "lint:fix": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo clippy --all-targets --fix --allow-dirty --allow-staged && cargo fmt\" stellar",
     "resolve-dependencies": "pnpm exec build-utils-rust resolve",
     "test": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo nextest run\" stellar",
     "test:snapshot:check": "pnpm exec turbo-snapshot check",

package/rustfmt.toml

@@ -1,15 +1,12 @@
-format_macro_bodies = true
+# Only stable rustfmt options are kept here: the Stellar docker toolchain runs
+# rustfmt on the stable channel (rust 1.90.0), which silently drops unstable
+# options (they only apply on nightly). Do not re-add unstable options unless the
+# tooling is switched to a pinned nightly (see the Solana packages for that setup).
 max_width = 120
-format_macro_matchers = true
-format_strings = true
-imports_granularity = "Crate"
-match_arm_blocks = false
-reorder_impl_items = true
-group_imports = "StdExternalCrate"
 use_field_init_shorthand = true
 use_small_heuristics = "Max"
-wrap_comments = true
-format_code_in_doc_comments = true
 
-# most of these are unstable, so we enable them
-unstable_features = true
+# style_edition is a stable option honored by the docker toolchain. Pin it to
+# 2021 to match every crate's `edition = "2021"` so formatting stays stable
+# across rustfmt versions (setting it to 2024 would reformat the code).
+style_edition = "2021"

package/upgrader/src/tests/mod.rs

@@ -1 +1 @@
-pub mod test_upgrader;
+pub mod test_upgrader;

package/workers/dvn/src/tests/auth.rs

@@ -6,7 +6,7 @@ use crate::{
 use ed25519_dalek::{Signer, SigningKey};
 use rand::thread_rng;
 use soroban_sdk::{
-    auth::{ContractContext, Context},
+    auth::{Context, ContractContext},
     testutils::Address as _,
     vec, Address, BytesN, Env, IntoVal, Symbol, Val, Vec,
 };
@@ -35,10 +35,7 @@ impl Ed25519KeyPair {
 }
 
 /// Creates a single self-call auth context and matching Call for testing.
-fn make_self_call_context(
-    env: &Env,
-    contract_id: &soroban_sdk::Address,
-) -> (Vec<Context>, Vec<Call>) {
+fn make_self_call_context(env: &Env, contract_id: &soroban_sdk::Address) -> (Vec<Context>, Vec<Call>) {
     let fn_name = Symbol::new(env, "set_paused");
     let args: Vec<Val> = vec![env, true.into_val(env)];
 
@@ -67,12 +64,7 @@ fn make_upgrade_contexts(
     let upgrader_ctx = Context::Contract(ContractContext {
         contract: upgrader_id.clone(),
         fn_name: Symbol::new(env, "upgrade_and_migrate"),
-        args: vec![
-            env,
-            contract_id.clone().into_val(env),
-            wasm_hash_val.clone(),
-            migration_data_val.clone(),
-        ],
+        args: vec![env, contract_id.clone().into_val(env), wasm_hash_val, migration_data_val],
     });
     // [1]: upgrade self-call
     let upgrade_ctx = Context::Contract(ContractContext {
@@ -374,12 +366,7 @@ fn test_check_auth_sender_none_fails_when_admin_required() {
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
     // Use Sender::None which should fail when admin is required
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -410,26 +397,15 @@ fn test_check_auth_set_admin_bypasses_admin_verification() {
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
 
-    let calls: Vec<Call> = vec![
-        &env,
-        Call {
-            to: setup.contract_id.clone(),
-            func: Symbol::new(&env, "set_admin"),
-            args: Vec::new(&env),
-        },
-    ];
+    let calls: Vec<Call> =
+        vec![&env, Call { to: setup.contract_id.clone(), func: Symbol::new(&env, "set_admin"), args: Vec::new(&env) }];
 
     let dvn_client = LzDVNClient::new(&env, &setup.contract_id);
     let hash = dvn_client.hash_call_data(&VID, &expiration, &calls);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
     // Use Sender::None - should succeed for set_admin since it bypasses admin verification
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -599,23 +575,14 @@ fn test_set_upgrader_requires_admin() {
 
     let calls: Vec<Call> = vec![
         &env,
-        Call {
-            to: setup.contract_id.clone(),
-            func: Symbol::new(&env, "set_upgrader"),
-            args: Vec::new(&env),
-        },
+        Call { to: setup.contract_id.clone(), func: Symbol::new(&env, "set_upgrader"), args: Vec::new(&env) },
     ];
 
     let dvn_client = LzDVNClient::new(&env, &setup.contract_id);
     let hash = dvn_client.hash_call_data(&VID, &expiration, &calls);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -692,12 +659,7 @@ fn test_check_auth_upgrade_no_upgrader_set() {
     let hash = dvn_client.hash_call_data(&VID, &expiration, &calls);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -733,12 +695,7 @@ fn test_check_auth_upgrade_wrong_upgrader() {
     let hash = dvn_client.hash_call_data(&VID, &expiration, &calls);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -784,12 +741,7 @@ fn test_check_auth_upgrade_missing_migrate() {
     let hash = dvn_client.hash_call_data(&VID, &expiration, &dummy_calls);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData {
-        vid: VID,
-        expiration,
-        signatures: vec![&env, sig],
-        sender: Sender::None,
-    };
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], sender: Sender::None };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,

package/workers/executor/src/auth.rs

@@ -111,13 +111,10 @@ impl LzExecutor {
         }
 
         // Helper path: first context must be on the registered executor helper
-        let helper_config =
-            ExecutorStorage::executor_helper(env).ok_or(ExecutorError::UnauthorizedContext)?;
+        let helper_config = ExecutorStorage::executor_helper(env).ok_or(ExecutorError::UnauthorizedContext)?;
 
         // Validate first context: must be the helper address with an allowed function name
-        if first_ctx.contract != helper_config.address
-            || !helper_config.allowed_functions.contains(first_fn_name)
-        {
+        if first_ctx.contract != helper_config.address || !helper_config.allowed_functions.contains(first_fn_name) {
             return Err(ExecutorError::UnauthorizedContext);
         }
 
@@ -128,9 +125,7 @@ impl LzExecutor {
         };
 
         let second_fn_name = &second_ctx.fn_name;
-        if *second_fn_name != Symbol::new(env, "lz_receive")
-            && *second_fn_name != Symbol::new(env, "lz_compose")
-        {
+        if *second_fn_name != Symbol::new(env, "lz_receive") && *second_fn_name != Symbol::new(env, "lz_compose") {
             return Err(ExecutorError::UnauthorizedContext);
         }
 

package/workers/executor/src/storage.rs

@@ -1,5 +1,5 @@
 use common_macros::storage;
-use soroban_sdk::{contracttype, Address, Vec, Symbol};
+use soroban_sdk::{contracttype, Address, Symbol, Vec};
 
 use crate::DstConfig;
 

package/workers/executor/src/tests/auth.rs

@@ -252,7 +252,12 @@ fn test_check_auth_rejects_invalid_helper_fn_name() {
     let bad_addr: Vec<Context> = vec![
         &setup.env,
         contract_ctx(&setup.env, wrong_helper, "execute", Vec::new(&setup.env)),
-        contract_ctx(&setup.env, Address::generate(&setup.env), "lz_receive", vec![&setup.env, 0i128.into_val(&setup.env)]),
+        contract_ctx(
+            &setup.env,
+            Address::generate(&setup.env),
+            "lz_receive",
+            vec![&setup.env, 0i128.into_val(&setup.env)],
+        ),
     ];
     assert_eq!(check_auth(&setup, &payload, sig, &bad_addr), Err(Ok(ExecutorError::UnauthorizedContext)));
 }

package/workers/executor/src/tests/executor.rs

@@ -16,8 +16,8 @@ fn test_constructor_sets_endpoint_and_worker_config() {
 
     assert_eq!(setup.client.owner(), Some(setup.owner.clone()));
     assert_eq!(setup.client.admins(), setup.admins);
-    assert_eq!(setup.client.is_admin(&setup.admins.get(0).unwrap()), true);
-    assert_eq!(setup.client.is_supported_message_lib(&setup.send_lib), true);
+    assert!(setup.client.is_admin(&setup.admins.get(0).unwrap()));
+    assert!(setup.client.is_supported_message_lib(&setup.send_lib));
     assert_eq!(setup.client.message_libs(), vec![&setup.env, setup.send_lib.clone()]);
 
     assert_eq!(setup.client.endpoint(), setup.endpoint);
@@ -25,7 +25,7 @@ fn test_constructor_sets_endpoint_and_worker_config() {
     assert_eq!(setup.client.price_feed(), Some(setup.price_feed.clone()));
     assert_eq!(setup.client.worker_fee_lib(), Some(setup.worker_fee_lib.clone()));
     assert_eq!(setup.client.default_multiplier_bps(), setup.default_multiplier_bps);
-    assert_eq!(setup.client.paused(), false);
+    assert!(!setup.client.paused());
 }
 
 // =============================================================================
@@ -71,12 +71,12 @@ fn test_set_admin_add_and_remove() {
     // Add new admin
     setup.mock_owner_auth("set_admin", (&new_admin, true));
     setup.client.set_admin(&new_admin, &true);
-    assert_eq!(setup.client.is_admin(&new_admin), true);
+    assert!(setup.client.is_admin(&new_admin));
 
     // Remove that admin
     setup.mock_owner_auth("set_admin", (&new_admin, false));
     setup.client.set_admin(&new_admin, &false);
-    assert_eq!(setup.client.is_admin(&new_admin), false);
+    assert!(!setup.client.is_admin(&new_admin));
 }
 
 #[test]

package/workers/executor/src/tests/setup.rs

@@ -167,8 +167,7 @@ impl<'a> TestSetup<'a> {
 
         // Register executor helper config directly in storage
         let executor_helper = Address::generate(&env);
-        let allowed_functions: Vec<Symbol> =
-            vec![&env, Symbol::new(&env, "execute"), Symbol::new(&env, "compose")];
+        let allowed_functions: Vec<Symbol> = vec![&env, Symbol::new(&env, "execute"), Symbol::new(&env, "compose")];
         env.as_contract(&contract_id, || {
             crate::storage::ExecutorStorage::set_executor_helper(
                 &env,

package/workers/executor-fee-lib/src/tests/executor_fee_lib.rs

@@ -546,13 +546,13 @@ fn test_is_v1_eid() {
     let env = Env::default();
 
     // V1: eid < 30000
-    assert_eq!(ExecutorFeeLib::is_v1_eid_for_test(&env, 0), true);
-    assert_eq!(ExecutorFeeLib::is_v1_eid_for_test(&env, 1), true);
-    assert_eq!(ExecutorFeeLib::is_v1_eid_for_test(&env, 29_999), true);
+    assert!(ExecutorFeeLib::is_v1_eid_for_test(&env, 0));
+    assert!(ExecutorFeeLib::is_v1_eid_for_test(&env, 1));
+    assert!(ExecutorFeeLib::is_v1_eid_for_test(&env, 29_999));
 
     // V2: eid >= 30000
-    assert_eq!(ExecutorFeeLib::is_v1_eid_for_test(&env, 30_000), false);
-    assert_eq!(ExecutorFeeLib::is_v1_eid_for_test(&env, 30_001), false);
+    assert!(!ExecutorFeeLib::is_v1_eid_for_test(&env, 30_000));
+    assert!(!ExecutorFeeLib::is_v1_eid_for_test(&env, 30_001));
 }
 
 #[test]

package/workers/executor-fee-lib/src/tests/executor_option.rs

@@ -23,7 +23,7 @@ fn test_parse_executor_options_aggregates_values() {
     assert_eq!(agg.total_gas, 17); // 10 + 7
     assert_eq!(agg.total_value, 10); // 2 + 5 + 3
     assert_eq!(agg.num_lz_compose, 1);
-    assert_eq!(agg.ordered, true);
+    assert!(agg.ordered);
 }
 
 #[test]
@@ -53,7 +53,7 @@ fn test_parse_executor_options_accumulates_multiple_lz_receive_gas_and_value() {
     assert_eq!(agg.total_gas, 30);
     assert_eq!(agg.total_value, 5);
     assert_eq!(agg.num_lz_compose, 0);
-    assert_eq!(agg.ordered, false);
+    assert!(!agg.ordered);
 }
 
 #[test]

package/workers/executor-helper/src/executor_helper.rs

@@ -120,7 +120,6 @@ impl ExecutorHelper {
     ) {
         ExecutorClient::new(env, executor).native_drop(admin, origin, &dst_eid, oapp, params);
     }
-
 }
 
 #[inline]

package/workers/executor-helper/src/tests/executor_helper.rs

@@ -338,4 +338,3 @@ fn test_lz_compose_alert_with_empty_reason() {
     assert!(record.is_some());
     assert_eq!(record.unwrap().reason.len(), 0);
 }
-