@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/utils/src/upgradeable.rs

@@ -1,33 +1,29 @@
-use crate::{
-    self as utils,
-    auth::{self, Auth},
-    errors::UpgradeableError,
-    option_ext::OptionExt,
-};
-use common_macros::{contract_trait, storage};
+use crate::{self as utils, auth::Auth, errors::UpgradeableError, option_ext::OptionExt};
+use common_macros::{contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, xdr::FromXdr, Env};
 
-// ============================================
-// Upgradeable Interface
-// ============================================
-
 /// Trait for contracts with upgrade and migration support.
+///
+/// Implements a two-phase upgrade pattern:
+/// 1. `upgrade` - Updates WASM bytecode and sets migration flag
+/// 2. `migrate` - Runs state migration and clears the flag
+///
+/// Requires implementing [`UpgradeableInternal`] and [`Auth`].
 #[contract_trait]
 pub trait Upgradeable: UpgradeableInternal + Auth {
-    /// The type of data required for migration.
     /// Upgrades the contract to new WASM bytecode.
     /// Sets a migration flag that must be cleared by calling `migrate`.
+    #[only_auth]
     fn upgrade(env: &soroban_sdk::Env, new_wasm_hash: &soroban_sdk::BytesN<32>) {
-        auth::require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_frozen(env), UpgradeableError::UpgradesFrozen);
         UpgradeableStorage::set_migrating(env, &true);
         env.deployer().update_current_contract_wasm(new_wasm_hash.clone());
     }
 
     /// Runs migration logic after an upgrade.
-    /// Can only be called when the migration flag is set by a previous `upgrade` call.
+    /// Parses XDR-encoded `migration_data` and calls `__migrate`. Clears the migration flag on success.
+    #[only_auth]
     fn migrate(env: &soroban_sdk::Env, migration_data: &soroban_sdk::Bytes) {
-        auth::require_auth::<Self>(env);
         assert_with_error!(env, UpgradeableStorage::migrating(env), UpgradeableError::MigrationNotAllowed);
 
         // Parse the migration data and call the internal migration logic
@@ -40,10 +36,10 @@ pub trait Upgradeable: UpgradeableInternal + Auth {
         UpgradeableStorage::set_migrating(env, &false);
     }
 
-    /// Permanently freezes the contract, preventing any future upgrades.
-    /// This action is irreversible.
+    /// Permanently freezes the contract, preventing any future upgrades. Irreversible.
+    #[only_auth]
     fn freeze(env: &soroban_sdk::Env) {
-        auth::require_auth::<Self>(env);
+        assert_with_error!(env, !Self::is_frozen(env), UpgradeableError::UpgradesFrozen);
         UpgradeableStorage::set_frozen(env, &true);
     }
 
@@ -54,27 +50,28 @@ pub trait Upgradeable: UpgradeableInternal + Auth {
 }
 
 /// Trait for defining contract-specific migration logic.
-/// Contracts using `#[upgradeable]` must implement this trait.
+/// Must be implemented by contracts using [`Upgradeable`].
 pub trait UpgradeableInternal {
-    /// The type of data required for migration.
-    /// This is the type used as the `migration_data` parameter in `Upgradeable::migrate` for this contract.
+    /// The XDR-decodable type for migration data. Use `()` if not needed.
     type MigrationData: FromXdr;
 
-    /// Internal migration logic to be implemented by the contract.
+    /// Migration logic called by `migrate`. Implement state transformations here.
     fn __migrate(env: &Env, migration_data: &Self::MigrationData);
 }
 
 // ============================================
-// Storage and Helper Functions
+// Storage
 // ============================================
 
-/// Storage keys for upgrade migration state.
+/// Storage for upgrade state.
 #[storage]
 pub enum UpgradeableStorage {
+    /// Whether upgrades are permanently disabled.
     #[instance(bool)]
     #[default(false)]
     Frozen,
 
+    /// Whether a migration is pending.
     #[instance(bool)]
     #[default(false)]
     Migrating,

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

@@ -47,7 +47,7 @@ impl CustomAccountInterface for LzDVN {
         }
         DvnStorage::set_used_hash(&env, &hash, &true);
 
-        // 4. Multisig verification (most expensive - do last)
+        // 4. MultiSig verification (most expensive - do last)
         Self::verify_signatures(&env, &hash, &signatures);
 
         Ok(())

package/contracts/workers/dvn/src/interfaces/dvn.rs

@@ -1,6 +1,6 @@
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{contractclient, contracttype, Address, BytesN, Env, Symbol, Val, Vec};
-use utils::multisig::Multisig;
+use utils::multisig::MultiSig;
 use worker::Worker;
 
 // ============================================================================
@@ -82,7 +82,7 @@ pub struct Call {
 /// Extends the LayerZero DVN interface with destination configuration management
 /// and multisig capabilities for secure cross-chain message verification.
 #[contractclient(name = "DVNClient")]
-pub trait IDVN: ILayerZeroDVN + Worker + Multisig {
+pub trait IDVN: ILayerZeroDVN + Worker + MultiSig {
     /// Sets the configuration for one or more destination chains.
     ///
     /// # Arguments

package/contracts/workers/dvn/src/storage.rs

@@ -4,7 +4,7 @@ use soroban_sdk::BytesN;
 
 /// DVN contract storage keys.
 ///
-/// Note: Multisig storage (Signers, Threshold) is provided by `utils::multisig::MultisigStorage`.
+/// Note: MultiSig storage (Signers, Threshold) is provided by `utils::multisig::MultiSigStorage`.
 #[storage]
 pub enum DvnStorage {
     /// Verifier ID - unique identifier for this DVN instance.

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

@@ -134,15 +134,15 @@ fn test_check_auth_wrong_signer_fails() {
         sender: Sender::Admin(public_key, signature),
     };
 
-    // verify_signatures panics with MultisigError::SignerNotFound when signer is not found
-    let res = env.try_invoke_contract_check_auth::<utils::errors::MultisigError>(
+    // verify_signatures panics with MultiSigError::SignerNotFound when signer is not found
+    let res = env.try_invoke_contract_check_auth::<utils::errors::MultiSigError>(
         &setup.contract_id,
         &payload,
         tx_auth.into_val(&env),
         &auth_contexts,
     );
 
-    assert_eq!(res, Err(Ok(utils::errors::MultisigError::SignerNotFound)));
+    assert_eq!(res, Err(Ok(utils::errors::MultiSigError::SignerNotFound)));
 }
 
 #[test]
@@ -265,3 +265,136 @@ fn test_check_auth_hash_already_used_fails() {
 
     assert_eq!(res2, Err(Ok(DvnError::HashAlreadyUsed)));
 }
+
+#[test]
+fn test_check_auth_sender_none_fails_when_admin_required() {
+    extern crate std;
+    use crate::Sender;
+
+    let setup = TestSetup::new(1);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    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 res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res, Err(Ok(DvnError::OnlyAdmin)));
+}
+
+#[test]
+fn test_check_auth_set_admin_bypasses_admin_verification() {
+    extern crate std;
+    use crate::{Call, LzDVNClient, Sender};
+    use soroban_sdk::{auth::ContractContext, Symbol};
+
+    let setup = TestSetup::new(1);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+
+    // Create a context for set_admin call on the DVN contract
+    let set_admin_context = Context::Contract(ContractContext {
+        contract: setup.contract_id.clone(),
+        fn_name: Symbol::new(&env, "set_admin"),
+        args: Vec::new(&env),
+    });
+    let auth_contexts: Vec<Context> = vec![&env, set_admin_context.clone()];
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+
+    // Create Call structs matching what extract_contract_calls would produce
+    let calls: Vec<Call> = vec![
+        &env,
+        Call {
+            to: setup.contract_id.clone(),
+            func: Symbol::new(&env, "set_admin"),
+            args: Vec::new(&env),
+        }
+    ];
+
+    // Use the contract's hash_call_data function directly
+    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 res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    // Should succeed because set_admin bypasses admin verification
+    assert!(res.is_ok(), "Expected success for set_admin call, got {:?}", res);
+}
+
+#[test]
+fn test_check_auth_non_contract_context_fails() {
+    extern crate std;
+    use crate::Sender;
+    use soroban_sdk::auth::{ContractExecutable, CreateContractHostFnContext};
+
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+
+    // Create a non-Contract context (CreateContractHostFn)
+    let non_contract_context = Context::CreateContractHostFn(CreateContractHostFnContext {
+        executable: ContractExecutable::Wasm(BytesN::from_array(&env, &[0; 32])),
+        salt: BytesN::from_array(&env, &[0; 32]),
+    });
+    let auth_contexts: Vec<Context> = vec![&env, non_contract_context];
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
+
+    // Use empty hash for signatures since we expect early error
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    // Should fail with NonContractInvoke error
+    assert_eq!(res, Err(Ok(DvnError::NonContractInvoke)));
+}

package/contracts/workers/dvn/src/tests/mod.rs

@@ -1,5 +1,4 @@
 pub mod auth;
 pub mod dvn;
 pub mod key_pair;
-pub mod multisig;
 pub mod setup;

package/contracts/workers/dvn/src/tests/setup.rs

@@ -5,20 +5,18 @@ extern crate std;
 use crate::{dvn::LzDVN, tests::key_pair::KeyPair};
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
 use std::vec::Vec as StdVec;
-use utils::multisig::MultisigClient;
 
 pub const VID: u32 = 1;
 pub const DEFAULT_MULTIPLIER_BPS: u32 = 10000;
 
-pub struct TestSetup<'a> {
+pub struct TestSetup {
     pub env: Env,
     pub contract_id: Address,
-    pub multisig_client: MultisigClient<'a>,
     pub key_pairs: StdVec<KeyPair>,
     pub admins: Vec<Address>,
 }
 
-impl<'a> TestSetup<'a> {
+impl TestSetup {
     /// Create a new test setup with the specified number of signers
     /// Threshold defaults to signer_count
     pub fn new(signer_count: u32) -> Self {
@@ -56,9 +54,7 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultisigClient::new(&env, &contract_id);
-
-        Self { env, contract_id, multisig_client, key_pairs, admins }
+        Self { env, contract_id, key_pairs, admins }
     }
 
     /// Create a new test setup with additional admins (as Ed25519 public key bytes)
@@ -98,8 +94,6 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultisigClient::new(&env, &contract_id);
-
-        Self { env, contract_id, multisig_client, key_pairs, admins }
+        Self { env, contract_id, key_pairs, admins }
     }
 }

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

@@ -182,3 +182,282 @@ fn test_native_drop_with_empty_params() {
     assert!(record.is_some());
     assert_eq!(record.unwrap().params.len(), 0);
 }
+
+// =============================================================================
+// execute() with value tests
+// =============================================================================
+
+#[test]
+fn test_execute_with_value_transfers_tokens() {
+    let setup = TestSetup::new();
+    let mut params = setup.default_execution_params();
+    params.value = 50;
+
+    // Mint tokens to admin (value payer)
+    setup.mint_native(&setup.admin, 100);
+
+    let admin_before = setup.balance_native(&setup.admin);
+    let executor_before = setup.balance_native(&setup.executor);
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.execute(&setup.executor, &params, &setup.admin);
+
+    // Verify token transfer occurred
+    assert_eq!(setup.balance_native(&setup.admin), admin_before - 50);
+    assert_eq!(setup.balance_native(&setup.executor), executor_before + 50);
+
+    // Verify lz_receive was called with correct value
+    let record = setup.receiver_client().get_lz_receive();
+    assert!(record.is_some());
+    assert_eq!(record.unwrap().value, 50);
+}
+
+#[test]
+fn test_execute_with_exact_balance_value() {
+    let setup = TestSetup::new();
+    let mut params = setup.default_execution_params();
+    params.value = 100;
+
+    // Mint exactly the amount needed
+    setup.mint_native(&setup.admin, 100);
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.execute(&setup.executor, &params, &setup.admin);
+
+    // Verify all tokens transferred
+    assert_eq!(setup.balance_native(&setup.admin), 0);
+    assert_eq!(setup.balance_native(&setup.executor), 100);
+}
+
+// =============================================================================
+// compose() with value tests
+// =============================================================================
+
+#[test]
+fn test_compose_with_value_transfers_tokens() {
+    let setup = TestSetup::new();
+    let mut params = setup.default_compose_params();
+    params.value = 75;
+
+    // Mint tokens to admin (value payer)
+    setup.mint_native(&setup.admin, 100);
+
+    let admin_before = setup.balance_native(&setup.admin);
+    let executor_before = setup.balance_native(&setup.executor);
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.compose(&setup.executor, &params, &setup.admin);
+
+    // Verify token transfer occurred
+    assert_eq!(setup.balance_native(&setup.admin), admin_before - 75);
+    assert_eq!(setup.balance_native(&setup.executor), executor_before + 75);
+
+    // Verify lz_compose was called with correct value
+    let record = setup.composer_client().get_lz_compose();
+    assert!(record.is_some());
+    assert_eq!(record.unwrap().value, 75);
+}
+
+// =============================================================================
+// lz_receive_alert() tests
+// =============================================================================
+
+#[test]
+fn test_lz_receive_alert_records_failure() {
+    let setup = TestSetup::new();
+    let params = setup.default_execution_params();
+    let reason = Bytes::from_slice(&setup.env, b"execution failed: out of gas");
+
+    setup.executor_helper_client.lz_receive_alert(&setup.executor, &params, &reason);
+
+    // Verify lz_receive_alert was called on endpoint with correct params
+    let record = setup.endpoint_client().get_lz_receive_alert();
+    assert!(record.is_some());
+    let record = record.unwrap();
+    assert_eq!(record.executor, setup.executor);
+    assert_eq!(record.origin, params.origin);
+    assert_eq!(record.receiver, params.receiver);
+    assert_eq!(record.guid, params.guid);
+    assert_eq!(record.gas_limit, params.gas_limit);
+    assert_eq!(record.value, params.value);
+    assert_eq!(record.message, params.message);
+    assert_eq!(record.extra_data, params.extra_data);
+    assert_eq!(record.reason, reason);
+}
+
+#[test]
+fn test_lz_receive_alert_with_empty_reason() {
+    let setup = TestSetup::new();
+    let params = setup.default_execution_params();
+    let reason = Bytes::new(&setup.env);
+
+    setup.executor_helper_client.lz_receive_alert(&setup.executor, &params, &reason);
+
+    let record = setup.endpoint_client().get_lz_receive_alert();
+    assert!(record.is_some());
+    assert_eq!(record.unwrap().reason.len(), 0);
+}
+
+// =============================================================================
+// lz_compose_alert() tests
+// =============================================================================
+
+#[test]
+fn test_lz_compose_alert_records_failure() {
+    let setup = TestSetup::new();
+    let params = setup.default_compose_params();
+    let reason = Bytes::from_slice(&setup.env, b"compose failed: invalid state");
+
+    setup.executor_helper_client.lz_compose_alert(&setup.executor, &params, &reason);
+
+    // Verify lz_compose_alert was called on endpoint with correct params
+    let record = setup.endpoint_client().get_lz_compose_alert();
+    assert!(record.is_some());
+    let record = record.unwrap();
+    assert_eq!(record.executor, setup.executor);
+    assert_eq!(record.from, params.from);
+    assert_eq!(record.to, params.to);
+    assert_eq!(record.guid, params.guid);
+    assert_eq!(record.index, params.index);
+    assert_eq!(record.gas_limit, params.gas_limit);
+    assert_eq!(record.value, params.value);
+    assert_eq!(record.message, params.message);
+    assert_eq!(record.extra_data, params.extra_data);
+    assert_eq!(record.reason, reason);
+}
+
+#[test]
+fn test_lz_compose_alert_with_empty_reason() {
+    let setup = TestSetup::new();
+    let params = setup.default_compose_params();
+    let reason = Bytes::new(&setup.env);
+
+    setup.executor_helper_client.lz_compose_alert(&setup.executor, &params, &reason);
+
+    let record = setup.endpoint_client().get_lz_compose_alert();
+    assert!(record.is_some());
+    assert_eq!(record.unwrap().reason.len(), 0);
+}
+
+// =============================================================================
+// native_drop_and_execute() tests
+// =============================================================================
+
+#[test]
+fn test_native_drop_and_execute_calls_both() {
+    let setup = TestSetup::new();
+    let origin = setup.default_origin();
+    let dst_eid = 2u32;
+    let oapp = Address::generate(&setup.env);
+
+    let receiver1 = Address::generate(&setup.env);
+    let native_drop_params: Vec<NativeDropParams> =
+        vec![&setup.env, NativeDropParams { receiver: receiver1.clone(), amount: 10 }];
+
+    let execute_params = setup.default_execution_params();
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.native_drop_and_execute(
+        &setup.executor,
+        &setup.admin,
+        &origin,
+        &dst_eid,
+        &oapp,
+        &native_drop_params,
+        &execute_params,
+    );
+
+    // Verify native_drop was called
+    let drop_record = setup.executor_client().get_native_drop();
+    assert!(drop_record.is_some());
+    let drop_record = drop_record.unwrap();
+    assert_eq!(drop_record.admin, setup.admin);
+    assert_eq!(drop_record.origin, origin);
+    assert_eq!(drop_record.dst_eid, dst_eid);
+    assert_eq!(drop_record.oapp, oapp);
+    assert_eq!(drop_record.params.len(), 1);
+    assert_eq!(drop_record.params.get(0).unwrap().receiver, receiver1);
+    assert_eq!(drop_record.params.get(0).unwrap().amount, 10);
+
+    // Verify lz_receive was also called
+    let receive_record = setup.receiver_client().get_lz_receive();
+    assert!(receive_record.is_some());
+    let receive_record = receive_record.unwrap();
+    assert_eq!(receive_record.executor, setup.executor);
+    assert_eq!(receive_record.origin, execute_params.origin);
+    assert_eq!(receive_record.guid, execute_params.guid);
+}
+
+#[test]
+fn test_native_drop_and_execute_with_empty_drop_params() {
+    let setup = TestSetup::new();
+    let origin = setup.default_origin();
+    let dst_eid = 1u32;
+    let oapp = Address::generate(&setup.env);
+    let native_drop_params: Vec<NativeDropParams> = vec![&setup.env];
+    let execute_params = setup.default_execution_params();
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.native_drop_and_execute(
+        &setup.executor,
+        &setup.admin,
+        &origin,
+        &dst_eid,
+        &oapp,
+        &native_drop_params,
+        &execute_params,
+    );
+
+    // Verify native_drop was called with empty params
+    let drop_record = setup.executor_client().get_native_drop();
+    assert!(drop_record.is_some());
+    assert_eq!(drop_record.unwrap().params.len(), 0);
+
+    // Verify lz_receive was still called
+    let receive_record = setup.receiver_client().get_lz_receive();
+    assert!(receive_record.is_some());
+}
+
+#[test]
+fn test_native_drop_and_execute_with_value_transfer() {
+    let setup = TestSetup::new();
+    let origin = setup.default_origin();
+    let dst_eid = 2u32;
+    let oapp = Address::generate(&setup.env);
+
+    let receiver1 = Address::generate(&setup.env);
+    let native_drop_params: Vec<NativeDropParams> =
+        vec![&setup.env, NativeDropParams { receiver: receiver1.clone(), amount: 10 }];
+
+    let mut execute_params = setup.default_execution_params();
+    execute_params.value = 25; // Add value to trigger token transfer
+
+    // Mint tokens to admin (value payer)
+    setup.mint_native(&setup.admin, 100);
+    let admin_before = setup.balance_native(&setup.admin);
+    let executor_before = setup.balance_native(&setup.executor);
+
+    setup.mock_all_auths();
+    setup.executor_helper_client.native_drop_and_execute(
+        &setup.executor,
+        &setup.admin,
+        &origin,
+        &dst_eid,
+        &oapp,
+        &native_drop_params,
+        &execute_params,
+    );
+
+    // Verify token transfer occurred
+    assert_eq!(setup.balance_native(&setup.admin), admin_before - 25);
+    assert_eq!(setup.balance_native(&setup.executor), executor_before + 25);
+
+    // Verify both operations occurred
+    let drop_record = setup.executor_client().get_native_drop();
+    assert!(drop_record.is_some());
+    assert_eq!(drop_record.unwrap().params.len(), 1);
+
+    let receive_record = setup.receiver_client().get_lz_receive();
+    assert!(receive_record.is_some());
+    assert_eq!(receive_record.unwrap().value, 25);
+}