@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.21

package/contracts/utils/src/tests/testing_utils.rs

@@ -1,5 +1,5 @@
-use crate::testing_utils::{assert_event, assert_events, ExpectedEvent, IntoExpectedEvent};
-use soroban_sdk::{contract, contractevent, contractimpl, testutils::Address as _, Address, Env, IntoVal, Val, Vec};
+use crate::testing_utils::{assert_contains_event, assert_contains_events, assert_eq_event, assert_eq_events};
+use soroban_sdk::{contract, contractevent, contractimpl, testutils::Address as _, Address, Env};
 
 // ============================================
 // Test Fixtures
@@ -78,7 +78,7 @@ impl TestingUtilsContract {
 }
 
 // ============================================
-// assert_event
+// assert_eq_event
 // ============================================
 
 // Basic functionality
@@ -91,7 +91,7 @@ fn test_assert_event_found() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
@@ -102,7 +102,7 @@ fn test_assert_event_with_multiple_fields() {
 
     client.emit_event2(&123, &456);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 456 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 123, count: 456 });
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn test_assert_event_with_address() {
     let addr = Address::generate(&env);
     client.emit_event3(&addr);
 
-    assert_event(&env, &contract_id, TestEvent3 { address: addr });
+    assert_eq_event(&env, &contract_id, TestEvent3 { address: addr });
 }
 
 #[test]
@@ -125,8 +125,8 @@ fn test_assert_event_among_multiple() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 10 });
-    assert_event(&env, &contract_id, TestEvent1 { value: 20 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 10 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 20 });
 }
 
 // Edge cases
@@ -139,7 +139,7 @@ fn test_assert_event_finds_first_matching_event() {
 
     client.emit_multiple_events(&42, &42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
@@ -151,23 +151,23 @@ fn test_assert_event_finds_correct_event_among_many() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_mixed_four_events(&1, &100, &200, &2, &3);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 2 });
-    assert_event(&env, &contract_id, TestEvent2 { name: 100, count: 200 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 2 });
+    assert_contains_event(&env, &contract_id, TestEvent2 { name: 100, count: 200 });
 }
 
 // Error cases
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_no_events_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -175,11 +175,11 @@ fn test_assert_event_not_found() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 100 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 100 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_wrong_contract() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -188,11 +188,11 @@ fn test_assert_event_wrong_contract() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &other_contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &other_contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_topics_length_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -200,11 +200,11 @@ fn test_assert_event_topics_length_mismatch() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 42, count: 0 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 42, count: 0 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_data_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -212,11 +212,11 @@ fn test_assert_event_data_mismatch() {
 
     client.emit_event2(&123, &456);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
 }
 
 // ============================================
-// assert_events
+// assert_eq_events
 // ============================================
 
 // Basic functionality
@@ -229,7 +229,7 @@ fn test_assert_events_single() {
 
     client.emit_event1(&42);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
@@ -240,11 +240,7 @@ fn test_assert_events_multiple_same_type() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 20 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 20 }]);
 }
 
 #[test]
@@ -255,11 +251,7 @@ fn test_assert_events_multiple_different_types() {
 
     client.emit_both_events(&42, &123, &456);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent2 { name: 123, count: 456 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 123, count: 456 }]);
 }
 
 #[test]
@@ -270,11 +262,7 @@ fn test_assert_events_order_independent() {
 
     client.emit_both_events(&42, &123, &456);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent2 { name: 123, count: 456 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 123, count: 456 }]);
 }
 
 #[test]
@@ -282,7 +270,7 @@ fn test_assert_events_empty_list() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_events(&env, &contract_id, &[]);
+    assert_eq_events(&env, &contract_id, &[]);
 }
 
 #[test]
@@ -293,11 +281,7 @@ fn test_assert_events_with_duplicates() {
 
     client.emit_multiple_events(&42, &42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
 }
 
 // Edge cases
@@ -311,7 +295,7 @@ fn test_assert_events_partial_match() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_two_plus_event2(&10, &20, &100, &200);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 10 }.expected(&env)]);
+    assert_contains_events(&env, &contract_id, &[&TestEvent1 { value: 10 }]);
 }
 
 #[test]
@@ -323,14 +307,10 @@ fn test_assert_events_three_events() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_three_events(&1, &2, &3);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent1 { value: 1 }.expected(&env),
-            TestEvent1 { value: 2 }.expected(&env),
-            TestEvent1 { value: 3 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 1 }, &TestEvent1 { value: 2 }, &TestEvent1 { value: 3 }],
     );
 }
 
@@ -345,14 +325,10 @@ fn test_assert_events_mixed_event_types_three() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_mixed_three_types(&42, &100, &200, &addr);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent3 { address: addr.clone() }.expected(&env),
-            TestEvent1 { value: 42 }.expected(&env),
-            TestEvent2 { name: 100, count: 200 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 100, count: 200 }, &TestEvent3 { address: addr.clone() }],
     );
 }
 
@@ -368,21 +344,17 @@ fn test_assert_events_from_specific_contract_ignores_others() {
     client1.emit_multiple_events(&10, &30);
 
     // Assert events from contract1 are found when using contract1's address
-    assert_events(
-        &env,
-        &contract_id1,
-        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 30 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id1, &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 30 }]);
 
     // Verify that using contract2's address doesn't match contract1's events
     // (this tests the filtering logic - events should not be found for wrong contract)
-    assert_events(&env, &contract_id2, &[]);
+    assert_contains_events(&env, &contract_id2, &[]);
 }
 
 // Error cases
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_first_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -390,11 +362,11 @@ fn test_assert_events_first_not_found() {
 
     client.emit_event1(&42);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 100 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 100 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #1 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_second_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -402,15 +374,11 @@ fn test_assert_events_second_not_found() {
 
     client.emit_event1(&42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 100 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 100 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #2 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_third_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -418,19 +386,15 @@ fn test_assert_events_third_not_found() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent1 { value: 10 }.expected(&env),
-            TestEvent1 { value: 20 }.expected(&env),
-            TestEvent1 { value: 30 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 20 }, &TestEvent1 { value: 30 }],
     );
 }
 
 #[test]
-#[should_panic(expected = "Expected event #1 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_duplicate_expected_but_not_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -438,24 +402,20 @@ fn test_assert_events_duplicate_expected_but_not_emitted() {
 
     client.emit_event1(&42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_no_events_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_wrong_contract() {
     let env = Env::default();
     let contract_id1 = env.register(TestingUtilsContract, ());
@@ -464,27 +424,11 @@ fn test_assert_events_wrong_contract() {
 
     client1.emit_event1(&42);
 
-    assert_events(&env, &contract_id2, &[TestEvent1 { value: 42 }.expected(&env)]);
-}
-
-#[test]
-#[should_panic(expected = "Expected event #0 not found")]
-fn test_assert_events_topics_length_mismatch() {
-    let env = Env::default();
-    let contract_id = env.register(TestingUtilsContract, ());
-    let client = TestingUtilsContractClient::new(&env, &contract_id);
-
-    client.emit_event1(&42);
-
-    let empty_topics: Vec<Val> = Vec::new(&env);
-    let data: Val = 42u32.into_val(&env);
-    let expected_with_empty_topics = ExpectedEvent { topics: empty_topics, data };
-
-    assert_events(&env, &contract_id, &[expected_with_empty_topics]);
+    assert_eq_events(&env, &contract_id2, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_data_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -492,66 +436,5 @@ fn test_assert_events_data_mismatch() {
 
     client.emit_event2(&100, &200);
 
-    assert_events(&env, &contract_id, &[TestEvent2 { name: 100, count: 999 }.expected(&env)]);
-}
-
-// ============================================
-// ExpectedEvent & IntoExpectedEvent
-// ============================================
-
-#[test]
-fn test_into_expected_event() {
-    let env = Env::default();
-
-    let event = TestEvent1 { value: 42 };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_into_expected_event_with_multiple_fields() {
-    let env = Env::default();
-
-    let event = TestEvent2 { name: 123, count: 456 };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_into_expected_event_with_address() {
-    let env = Env::default();
-
-    let addr = Address::generate(&env);
-    let event = TestEvent3 { address: addr };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_expected_event_struct() {
-    let env = Env::default();
-
-    let topics: Vec<Val> = Vec::new(&env);
-    let data: Val = 42u32.into_val(&env);
-
-    let expected = ExpectedEvent { topics, data };
-
-    assert_eq!(expected.topics.len(), 0);
-}
-
-#[test]
-fn test_expected_event_with_topics() {
-    let env = Env::default();
-
-    let mut topics: Vec<Val> = Vec::new(&env);
-    topics.push_back(42u32.into_val(&env));
-    topics.push_back(100u64.into_val(&env));
-    let data: Val = 999u32.into_val(&env);
-
-    let expected = ExpectedEvent { topics, data };
-
-    assert_eq!(expected.topics.len(), 2);
+    assert_eq_events(&env, &contract_id, &[&TestEvent2 { name: 100, count: 999 }]);
 }

package/contracts/utils/src/tests/ttl_configurable.rs

@@ -5,7 +5,7 @@ use crate::{
     errors::{OwnableError, TtlConfigurableError},
     option_ext::OptionExt,
     ownable::{Ownable, OwnableInitializer},
-    testing_utils::assert_event,
+    testing_utils::assert_eq_event,
     ttl_configurable::{
         TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
     },
@@ -314,7 +314,7 @@ fn test_default_ttl_configurable_set_all() {
     let persistent = Some(persistent_cfg);
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
 
-    assert_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
 
     let (instance, persistent) = client.configurable_ttl_configs();
     assert_eq!(instance, Some(instance_cfg));
@@ -331,7 +331,7 @@ fn test_default_ttl_configurable_set_partial() {
     let instance = Some(instance_cfg);
     let persistent = None;
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
-    assert_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
 
     let (instance, persistent) = client.configurable_ttl_configs();
     assert_eq!(instance, Some(instance_cfg));
@@ -375,7 +375,7 @@ fn test_default_ttl_configurable_freeze() {
 
     assert!(!client.is_ttl_configs_frozen());
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
-    assert_event(&env, &contract_id, TtlConfigsFrozen {});
+    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
     assert!(client.is_ttl_configs_frozen());
 }
 
@@ -398,7 +398,7 @@ fn test_default_ttl_configurable_freeze_when_already_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
-    assert_event(&env, &contract_id, TtlConfigsFrozen {});
+    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
 }
 

package/contracts/utils/src/tests/upgradeable.rs

@@ -1,5 +1,5 @@
 use crate::upgradeable::{Upgradeable, UpgradeableInternal, UpgradeableStorage};
-use soroban_sdk::{contract, contractimpl, xdr::ToXdr, Address, Bytes, BytesN, Env, Symbol, Val};
+use soroban_sdk::{contract, contractimpl, xdr::ToXdr, Address, Bytes, Env, Symbol, Val};
 
 // #![no_std]
 

package/contracts/utils/src/ttl_configurable.rs

@@ -111,7 +111,11 @@ pub trait TtlConfigurable: Auth {
     /// # Panics
     /// - `TtlConfigFrozen` if configs are frozen
     /// - `InvalidTtlConfig` if validation fails
-    fn set_ttl_configs(env: &Env, instance: &Option<TtlConfig>, persistent: &Option<TtlConfig>) {
+    fn set_ttl_configs(
+        env: &soroban_sdk::Env,
+        instance: &Option<utils::ttl_configurable::TtlConfig>,
+        persistent: &Option<utils::ttl_configurable::TtlConfig>,
+    ) {
         auth::require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlConfigurableError::TtlConfigFrozen);
 
@@ -126,7 +130,9 @@ pub trait TtlConfigurable: Auth {
     }
 
     /// Returns the current TTL configs as (instance_config, persistent_config).
-    fn ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
+    fn ttl_configs(
+        env: &soroban_sdk::Env,
+    ) -> (Option<utils::ttl_configurable::TtlConfig>, Option<utils::ttl_configurable::TtlConfig>) {
         (TtlConfigStorage::instance(env), TtlConfigStorage::persistent(env))
     }
 
@@ -137,7 +143,7 @@ pub trait TtlConfigurable: Auth {
     ///
     /// # Panics
     /// - `TtlConfigAlreadyFrozen` if already frozen
-    fn freeze_ttl_configs(env: &Env) {
+    fn freeze_ttl_configs(env: &soroban_sdk::Env) {
         auth::require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlConfigurableError::TtlConfigAlreadyFrozen);
 
@@ -147,7 +153,7 @@ pub trait TtlConfigurable: Auth {
     }
 
     /// Returns whether TTL configs are frozen.
-    fn is_ttl_configs_frozen(env: &Env) -> bool {
+    fn is_ttl_configs_frozen(env: &soroban_sdk::Env) -> bool {
         TtlConfigStorage::frozen(env)
     }
 }

package/contracts/utils/src/upgradeable.rs

@@ -5,7 +5,7 @@ use crate::{
     option_ext::OptionExt,
 };
 use common_macros::{contract_trait, storage};
-use soroban_sdk::{assert_with_error, xdr::FromXdr, Bytes, BytesN, Env};
+use soroban_sdk::{assert_with_error, xdr::FromXdr, Env};
 
 // ============================================
 // Upgradeable Interface
@@ -17,7 +17,7 @@ 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`.
-    fn upgrade(env: &Env, new_wasm_hash: &BytesN<32>) {
+    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);
@@ -26,7 +26,7 @@ pub trait Upgradeable: UpgradeableInternal + Auth {
 
     /// Runs migration logic after an upgrade.
     /// Can only be called when the migration flag is set by a previous `upgrade` call.
-    fn migrate(env: &Env, migration_data: &Bytes) {
+    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);
 
@@ -42,13 +42,13 @@ pub trait Upgradeable: UpgradeableInternal + Auth {
 
     /// Permanently freezes the contract, preventing any future upgrades.
     /// This action is irreversible.
-    fn freeze(env: &Env) {
+    fn freeze(env: &soroban_sdk::Env) {
         auth::require_auth::<Self>(env);
         UpgradeableStorage::set_frozen(env, &true);
     }
 
     /// Returns whether the contract is frozen (upgrades disabled).
-    fn is_frozen(env: &Env) -> bool {
+    fn is_frozen(env: &soroban_sdk::Env) -> bool {
         UpgradeableStorage::frozen(env)
     }
 }

package/contracts/workers/dvn/Cargo.toml

@@ -14,7 +14,7 @@ crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]
-cfg-if = "1.0"
+cfg-if = { workspace = true }
 soroban-sdk = { workspace = true, features = ["hazmat-crypto"] }
 worker = { workspace = true }
 fee-lib-interfaces = { workspace = true }
@@ -25,8 +25,7 @@ endpoint-v2 = { workspace = true, features = ["library"] }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-k256 = "0.13"
-sha3 = "0.10"
-rand = "0.8"
-ed25519-dalek = "2"
+k256 = { workspace = true }
+sha3 = { workspace = true }
+rand = { workspace = true }
+ed25519-dalek = { workspace = true }

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

@@ -11,7 +11,7 @@ use endpoint_v2::FeeRecipient;
 use fee_lib_interfaces::{DvnFeeLibClient, DvnFeeParams};
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{xdr::ToXdr, Address, Bytes, BytesN, Env, Vec};
-use utils::{buffer_writer::BufferWriter, multisig, option_ext::OptionExt, upgradeable::UpgradeableInternal};
+use utils::{buffer_writer::BufferWriter, multisig, option_ext::OptionExt};
 use worker::{
     assert_acl, assert_not_paused, assert_supported_message_lib, errors::WorkerError, init_worker, require_admin_auth,
     set_admin_by_admin, Worker,
@@ -21,7 +21,7 @@ use worker::{
 ///
 /// Implements multisig-based verification with custom account authorization.
 /// The contract owns itself, allowing the multisig quorum to authorize operations.
-#[lz_contract(multisig, upgradeable)]
+#[lz_contract(multisig, upgradeable(no_migration))]
 pub struct LzDVN;
 
 // ============================================================================
@@ -189,16 +189,6 @@ impl ILayerZeroDVN for LzDVN {
 #[contract_impl(contracttrait)]
 impl Worker for LzDVN {}
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-/// No migration logic needed for initial upgrade capability
-impl UpgradeableInternal for LzDVN {
-    type MigrationData = ();
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {}
-}
-
 // ============================================================================
 // Include Auth Module
 // ============================================================================

package/contracts/workers/dvn-fee-lib/Cargo.toml

@@ -14,9 +14,9 @@ crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]
+cfg-if = { workspace = true }
 soroban-sdk = { workspace = true }
 common-macros = { workspace = true }
-message-lib-common = { workspace = true }
 utils = { workspace = true }
 fee-lib-interfaces = { workspace = true }