@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/utils/src/ttl_configurable.rs

@@ -1,6 +1,6 @@
 use crate::{
     self as utils,
-    auth::{require_auth, Auth},
+    auth::{self, Auth},
     errors::TtlConfigurableError,
 };
 use common_macros::contract_trait;
@@ -111,8 +111,12 @@ 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>) {
-        require_auth::<Self>(env);
+    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);
 
         let max_ttl = u32::min(MAX_TTL, env.storage().max_ttl());
@@ -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,8 +143,8 @@ pub trait TtlConfigurable: Auth {
     ///
     /// # Panics
     /// - `TtlConfigAlreadyFrozen` if already frozen
-    fn freeze_ttl_configs(env: &Env) {
-        require_auth::<Self>(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);
 
         TtlConfigStorage::set_frozen(env, &true);
@@ -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

@@ -1,20 +1,56 @@
-use crate::errors::UpgradeableError;
-use common_macros::storage;
-use soroban_sdk::{assert_with_error, BytesN, Env, FromVal, Val};
+use crate::{
+    self as utils,
+    auth::{self, Auth},
+    errors::UpgradeableError,
+    option_ext::OptionExt,
+};
+use common_macros::{contract_trait, storage};
+use soroban_sdk::{assert_with_error, xdr::FromXdr, Env};
 
 // ============================================
 // Upgradeable Interface
 // ============================================
 
 /// Trait for contracts with upgrade and migration support.
-pub trait Upgradeable: UpgradeableInternal {
+#[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`.
-    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);
+        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.
-    fn migrate(env: &Env, migration_data: &Self::MigrationData);
+    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
+        let parsed_data = Self::MigrationData::from_xdr(env, migration_data)
+            .ok()
+            .unwrap_or_panic(env, UpgradeableError::InvalidMigrationData);
+        Self::__migrate(env, &parsed_data);
+
+        // Clear the migration flag after migration is successful
+        UpgradeableStorage::set_migrating(env, &false);
+    }
+
+    /// Permanently freezes the contract, preventing any future upgrades.
+    /// This action is irreversible.
+    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: &soroban_sdk::Env) -> bool {
+        UpgradeableStorage::frozen(env)
+    }
 }
 
 /// Trait for defining contract-specific migration logic.
@@ -22,7 +58,7 @@ pub trait Upgradeable: UpgradeableInternal {
 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.
-    type MigrationData: FromVal<Env, Val>;
+    type MigrationData: FromXdr;
 
     /// Internal migration logic to be implemented by the contract.
     fn __migrate(env: &Env, migration_data: &Self::MigrationData);
@@ -36,21 +72,10 @@ pub trait UpgradeableInternal {
 #[storage]
 pub enum UpgradeableStorage {
     #[instance(bool)]
-    Migrating,
-}
-
-/// Upgrades the contract to new WASM bytecode and sets the migration flag.
-pub fn upgrade(env: &Env, new_wasm_hash: BytesN<32>) {
-    UpgradeableStorage::set_migrating(env, &true);
-    env.deployer().update_current_contract_wasm(new_wasm_hash);
-}
+    #[default(false)]
+    Frozen,
 
-/// Runs migration logic after an upgrade.
-/// Can only be called when the migration flag is set by a previous `upgrade` call.
-pub fn migrate<T: UpgradeableInternal>(env: &Env, migration_data: &T::MigrationData) {
-    assert_with_error!(env, UpgradeableStorage::migrating(env).unwrap_or(false), UpgradeableError::MigrationNotAllowed);
-    UpgradeableStorage::set_migrating(env, &false);
-    T::__migrate(env, migration_data);
+    #[instance(bool)]
+    #[default(false)]
+    Migrating,
 }
-
-// TODO (hanson): review and polish this

package/contracts/workers/dvn/Cargo.toml

@@ -14,9 +14,10 @@ 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 }
 message-lib-common = { workspace = true }
 utils = { workspace = true }
 common-macros = { workspace = true }
@@ -24,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/auth.rs

@@ -1,43 +1,12 @@
 use super::*;
+use crate::{Sender, TransactionAuthData};
 use soroban_sdk::{
     address_payload::AddressPayload,
     auth::{Context, CustomAccountInterface},
-    contracttype,
     crypto::Hash,
     vec, Symbol,
 };
 
-// ============================================================================
-// Authentication Data Types
-// ============================================================================
-
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum Sender {
-    /// No explicit sender (permissionless execution).
-    None,
-    /// A registered admin (ed25519) submitting the transaction.
-    /// The tuple is `(public_key, signature)` where the signature covers the Soroban payload.
-    Admin(BytesN<32>, BytesN<64>),
-}
-
-/// Authentication data for DVN contract transactions.
-///
-/// This struct is used with Soroban's custom account interface to authorize
-/// transactions through a combination of admin signature and multisig quorum.
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct TransactionAuthData {
-    /// Verifier ID - must match the DVN's configured VID.
-    pub vid: u32,
-    /// Expiration timestamp (ledger time) after which this auth is invalid.
-    pub expiration: u64,
-    /// Signatures from multisig signers (secp256k1, 65 bytes each).
-    pub signatures: Vec<BytesN<65>>,
-    /// Entity submitting the transaction (admin, or permissionless).
-    pub sender: Sender,
-}
-
 // ============================================================================
 // Custom Account Interface Implementation
 // ============================================================================
@@ -64,14 +33,14 @@ impl CustomAccountInterface for LzDVN {
             return Err(DvnError::AuthDataExpired);
         }
 
-        // 2. Admin verification (quorum_change_admin bypasses this - allows quorum-only admin changes)
-        let requires_admin = !Self::is_invoking_quorum_change_admin(&env, &auth_contexts);
+        // 2. Admin verification (`set_admin` bypasses this - allows quorum-only admin changes)
+        let requires_admin = !Self::is_invoking_worker_set_admin(&env, &auth_contexts);
         if requires_admin {
             Self::verify_admin_signature(&env, &sender, &signature_payload)?;
         }
 
         // 3. Replay protection
-        let calls = Self::collect_contract_calls(&env, &auth_contexts)?;
+        let calls = Self::extract_contract_calls(&env, &auth_contexts)?;
         let hash = Self::hash_call_data(&env, vid, expiration, &calls);
         if DvnStorage::used_hash(&env, &hash) {
             return Err(DvnError::HashAlreadyUsed);
@@ -110,24 +79,25 @@ impl LzDVN {
     }
 
     /// Collects contract calls from the auth contexts.
-    fn collect_contract_calls(env: &Env, auth_contexts: &Vec<Context>) -> Result<Vec<Call>, DvnError> {
-        auth_contexts.iter().try_fold(vec![env], |mut calls, context| {
+    fn extract_contract_calls(env: &Env, auth_contexts: &Vec<Context>) -> Result<Vec<Call>, DvnError> {
+        let mut calls = vec![env];
+        for context in auth_contexts.iter() {
             let Context::Contract(ctx) = context else {
                 return Err(DvnError::NonContractInvoke);
             };
             calls.push_back(Call { to: ctx.contract, func: ctx.fn_name, args: ctx.args });
-            Ok(calls)
-        })
+        }
+        Ok(calls)
     }
 
-    /// Checks if the first auth context is a call to `quorum_change_admin` on this contract.
+    /// Checks if the first auth context is a call to `set_admin` on this contract.
     ///
     /// Used to allow quorum-only admin changes without requiring existing admin authorization.
-    fn is_invoking_quorum_change_admin(env: &Env, auth_contexts: &Vec<Context>) -> bool {
+    fn is_invoking_worker_set_admin(env: &Env, auth_contexts: &Vec<Context>) -> bool {
         auth_contexts.len() == 1
             && auth_contexts.first().is_some_and(|ctx| {
                 let Context::Contract(c) = ctx else { return false };
-                c.contract == env.current_contract_address() && c.fn_name == Symbol::new(env, "quorum_change_admin")
+                c.contract == env.current_contract_address() && c.fn_name == Symbol::new(env, "set_admin")
             })
     }
 }

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

@@ -8,21 +8,20 @@
 use crate::{errors::DvnError, events::SetDstConfig, storage::DvnStorage, Call, DstConfig, DstConfigParam, IDVN};
 use common_macros::{contract_impl, lz_contract};
 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, ttl_configurable, upgradeable::UpgradeableInternal,
-};
+use utils::{buffer_writer::BufferWriter, multisig, option_ext::OptionExt};
 use worker::{
-    assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, set_admin_by_admin,
-    set_admin_by_owner, DvnFeeLibClient, DvnFeeParams, Worker,
+    assert_acl, assert_not_paused, assert_supported_message_lib, errors::WorkerError, init_worker, require_admin_auth,
+    set_admin_by_admin, Worker,
 };
 
 /// LayerZero DVN contract.
 ///
 /// 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;
 
 // ============================================================================
@@ -55,7 +54,6 @@ impl LzDVN {
         worker_fee_lib: &Address,
         deposit_address: &Address,
     ) {
-        ttl_configurable::init_default_ttl_configs(env);
         multisig::init_multisig(env, signers, threshold);
         init_worker::<Self>(
             env,
@@ -79,22 +77,9 @@ impl LzDVN {
     /// * `caller` - The admin calling this function (must provide authorization)
     /// * `admin` - The address to set admin status for
     /// * `active` - `true` to add admin, `false` to remove
-    pub fn set_admin(env: &Env, caller: &Address, admin: &Address, active: bool) {
+    pub fn set_admin_by_admin(env: &Env, caller: &Address, admin: &Address, active: bool) {
         set_admin_by_admin::<Self>(env, caller, admin, active);
     }
-
-    /// Allows the quorum to add/remove admins without requiring an admin signature.
-    ///
-    /// This function bypasses the normal admin verification in `__check_auth`,
-    /// requiring only multisig quorum signatures. Must be called as a single
-    /// operation (cannot be bundled with other calls).
-    ///
-    /// # Arguments
-    /// * `admin` - The address to set admin status for
-    /// * `active` - `true` to add admin, `false` to remove
-    pub fn quorum_change_admin(env: &Env, admin: &Address, active: bool) {
-        set_admin_by_owner::<Self>(env, admin, active);
-    }
 }
 
 // ============================================================================
@@ -106,9 +91,7 @@ impl IDVN for LzDVN {
     /// Sets destination chain configurations. Requires admin authorization.
     fn set_dst_config(env: &Env, admin: &Address, params: &Vec<DstConfigParam>) {
         require_admin_auth::<Self>(env, admin);
-        for param in params {
-            DvnStorage::set_dst_config(env, param.dst_eid, &param.config);
-        }
+        params.iter().for_each(|param| DvnStorage::set_dst_config(env, param.dst_eid, &param.config));
 
         SetDstConfig { params: params.clone() }.publish(env);
     }
@@ -120,6 +103,7 @@ impl IDVN for LzDVN {
 
     /// Returns the Verifier ID for this DVN.
     fn vid(env: &Env) -> u32 {
+        // VID is always set during initialization, so unwrap is safe here
         DvnStorage::vid(env).unwrap()
     }
 
@@ -156,12 +140,14 @@ impl ILayerZeroDVN for LzDVN {
         assert_acl::<Self>(env, sender);
 
         let dst_config = Self::dst_config(env, dst_eid).unwrap_or_panic(env, DvnError::EidNotSupported);
+        let price_feed = Self::price_feed(env).unwrap_or_panic(env, WorkerError::PriceFeedNotSet);
+        let worker_fee_lib = Self::worker_fee_lib(env).unwrap_or_panic(env, WorkerError::WorkerFeeLibNotSet);
         let params = DvnFeeParams {
             sender: sender.clone(),
             dst_eid,
             confirmations,
             options: options.clone(),
-            price_feed: Self::price_feed(env),
+            price_feed,
             default_multiplier_bps: Self::default_multiplier_bps(env),
             quorum: Self::threshold(env),
             gas: dst_config.gas,
@@ -169,7 +155,7 @@ impl ILayerZeroDVN for LzDVN {
             floor_margin_usd: dst_config.floor_margin_usd,
         };
 
-        DvnFeeLibClient::new(env, &Self::worker_fee_lib(env)).get_fee(&env.current_contract_address(), &params)
+        DvnFeeLibClient::new(env, &worker_fee_lib).get_fee(&env.current_contract_address(), &params)
     }
 
     /// Assigns a verification job to this DVN and returns fee payment info.
@@ -190,7 +176,8 @@ impl ILayerZeroDVN for LzDVN {
         assert_supported_message_lib::<Self>(env, send_lib);
 
         let fee = Self::get_fee(env, send_lib, sender, dst_eid, packet_header, payload_hash, confirmations, options);
-        FeeRecipient { amount: fee, to: Self::deposit_address(env) }
+        let deposit_address = Self::deposit_address(env).unwrap_or_panic(env, WorkerError::DepositAddressNotSet);
+        FeeRecipient { amount: fee, to: deposit_address }
     }
 }
 
@@ -202,21 +189,9 @@ impl ILayerZeroDVN for LzDVN {
 #[contract_impl(contracttrait)]
 impl Worker for LzDVN {}
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-impl UpgradeableInternal for LzDVN {
-    type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
-}
-
 // ============================================================================
 // Include Auth Module
 // ============================================================================
 
 #[path = "auth.rs"]
-pub mod auth;
+mod auth;

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

@@ -5,7 +5,6 @@ pub enum DvnError {
     AuthDataExpired,
     EidNotSupported,
     HashAlreadyUsed,
-    InvalidInvocation,
     InvalidVid,
     NonContractInvoke,
     OnlyAdmin,

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

@@ -3,6 +3,41 @@ use soroban_sdk::{contractclient, contracttype, Address, BytesN, Env, Symbol, Va
 use utils::multisig::Multisig;
 use worker::Worker;
 
+// ============================================================================
+// Authentication Data Types
+// ============================================================================
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Sender {
+    /// No explicit sender (permissionless execution).
+    None,
+    /// A registered admin (ed25519) submitting the transaction.
+    /// The tuple is `(public_key, signature)` where the signature covers the Soroban payload.
+    Admin(BytesN<32>, BytesN<64>),
+}
+
+/// Authentication data for DVN contract transactions.
+///
+/// This struct is used with Soroban's custom account interface to authorize
+/// transactions through a combination of admin signature and multisig quorum.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct TransactionAuthData {
+    /// Verifier ID - must match the DVN's configured VID.
+    pub vid: u32,
+    /// Expiration timestamp (ledger time) after which this auth is invalid.
+    pub expiration: u64,
+    /// Signatures from multisig signers (secp256k1, 65 bytes each).
+    pub signatures: Vec<BytesN<65>>,
+    /// Entity submitting the transaction (admin, or permissionless).
+    pub sender: Sender,
+}
+
+// ============================================================================
+// Destination Configuration Types
+// ============================================================================
+
 /// Configuration for a destination chain.
 ///
 /// Contains fee calculation parameters specific to each destination endpoint.

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

@@ -1,9 +1,10 @@
 #![no_std]
 
-pub mod errors;
+mod errors;
 pub mod events;
-pub mod interfaces;
+mod interfaces;
 
+pub use errors::*;
 pub use interfaces::*;
 
 cfg_if::cfg_if! {
@@ -11,7 +12,7 @@ cfg_if::cfg_if! {
         mod storage;
         mod dvn;
 
-        pub use dvn::*;
+        pub use dvn::{LzDVN, LzDVNClient};
     }
 }
 

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

@@ -1,7 +1,7 @@
 use crate::{
-    dvn::auth::{Sender, TransactionAuthData},
     errors::DvnError,
     tests::setup::{TestSetup, VID},
+    Sender, TransactionAuthData,
 };
 use ed25519_dalek::{Signer, SigningKey};
 use rand::thread_rng;

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

@@ -1,12 +1,13 @@
 use crate::{dvn::LzDVN, tests::setup::TestSetup, DVNClient, DstConfig, DstConfigParam, IDVN};
 use endpoint_v2::FeeRecipient;
+use fee_lib_interfaces::{DvnFeeParams, IDvnFeeLib};
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{
     contract, contractimpl,
     testutils::{Address as _, AuthorizedFunction},
     vec, Address, Bytes, BytesN, Env, IntoVal, Symbol,
 };
-use worker::{DvnFeeParams, IDvnFeeLib, Worker};
+use worker::Worker;
 
 fn with_contract<F, R>(setup: &TestSetup, f: F) -> R
 where
@@ -73,7 +74,7 @@ fn test_get_fee_missing_dst_config_panics() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotAllowed
+#[should_panic(expected = "Error(Contract, #1207)")] // WorkerError::NotAllowed
 fn test_get_fee_not_allowed_due_to_allowlist() {
     let setup = TestSetup::new(1);
     let allowed = new_addr(&setup.env);
@@ -166,7 +167,7 @@ fn test_pause_and_setters_happy_paths() {
         LzDVN::set_deposit_address(&setup.env, &admin, &other);
     });
     with_contract(&setup, || {
-        assert_eq!(LzDVN::deposit_address(&setup.env), other);
+        assert_eq!(LzDVN::deposit_address(&setup.env), Some(other));
     });
 
     let pf = new_addr(&setup.env);
@@ -174,12 +175,12 @@ fn test_pause_and_setters_happy_paths() {
         LzDVN::set_price_feed(&setup.env, &admin, &pf);
     });
     with_contract(&setup, || {
-        assert_eq!(LzDVN::price_feed(&setup.env), pf);
+        assert_eq!(LzDVN::price_feed(&setup.env), Some(pf));
     });
 
     let opts = Bytes::from_array(&setup.env, &[1, 2, 3]);
     with_contract(&setup, || {
-        LzDVN::set_supported_option_types(&setup.env, &admin, 77, opts.clone());
+        LzDVN::set_supported_option_types(&setup.env, &admin, 77, &opts);
     });
     with_contract(&setup, || {
         assert_eq!(LzDVN::get_supported_option_types(&setup.env, 77), Some(opts));
@@ -190,7 +191,7 @@ fn test_pause_and_setters_happy_paths() {
         LzDVN::set_worker_fee_lib(&setup.env, &admin, &fee_lib);
     });
     with_contract(&setup, || {
-        assert_eq!(LzDVN::worker_fee_lib(&setup.env), fee_lib);
+        assert_eq!(LzDVN::worker_fee_lib(&setup.env), Some(fee_lib));
     });
 }
 
@@ -278,7 +279,7 @@ fn test_set_admin_add() {
 
     // Add new admin by existing admin
     with_contract(&setup, || {
-        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, true);
+        LzDVN::set_admin_by_admin(&setup.env, &existing_admin, &new_admin, true);
     });
 
     // Verify new_admin is now an admin
@@ -294,12 +295,12 @@ fn test_set_admin_remove() {
 
     // Add new admin first
     with_contract(&setup, || {
-        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, true);
+        LzDVN::set_admin_by_admin(&setup.env, &existing_admin, &new_admin, true);
     });
 
     // Remove the new admin
     with_contract(&setup, || {
-        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, false);
+        LzDVN::set_admin_by_admin(&setup.env, &existing_admin, &new_admin, false);
     });
 
     // Verify new_admin is no longer an admin
@@ -308,7 +309,7 @@ fn test_set_admin_remove() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
+#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::Unauthorized
 fn test_set_admin_unauthorized() {
     let setup = TestSetup::new(1);
     let non_admin = new_addr(&setup.env);
@@ -316,20 +317,23 @@ fn test_set_admin_unauthorized() {
 
     // Attempt to add admin by non-admin should fail
     with_contract(&setup, || {
-        LzDVN::set_admin(&setup.env, &non_admin, &new_admin, true);
+        LzDVN::set_admin_by_admin(&setup.env, &non_admin, &new_admin, true);
     });
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1204)")] // WorkerError::AttemptingToRemoveOnlyAdmin
-fn test_set_admin_cannot_remove_last_admin() {
+fn test_set_admin_remove_last_admin() {
     let setup = TestSetup::new(1);
     let existing_admin = setup.admins.get(0).unwrap();
 
-    // Attempt to remove the only admin should fail
+    // Removing the only admin is now allowed
     with_contract(&setup, || {
-        LzDVN::set_admin(&setup.env, &existing_admin, &existing_admin, false);
+        LzDVN::set_admin_by_admin(&setup.env, &existing_admin, &existing_admin, false);
     });
+
+    // Verify admin is no longer an admin
+    let is_admin = with_contract(&setup, || LzDVN::is_admin(&setup.env, &existing_admin));
+    assert!(!is_admin);
 }
 
 #[contract]

package/contracts/workers/dvn/src/tests/multisig/set_threshold.rs

@@ -13,10 +13,8 @@ fn random_signer(env: &Env) -> BytesN<20> {
 }
 
 fn register_dvn(env: &Env, signer_count: usize, threshold: u32) {
-    let signers: Vec<BytesN<20>> = (0..signer_count).map(|_| random_signer(env)).fold(vec![env], |mut acc, s| {
-        acc.push_back(s);
-        acc
-    });
+    let mut signers: Vec<BytesN<20>> = vec![env];
+    (0..signer_count).map(|_| random_signer(env)).for_each(|s| signers.push_back(s));
     let admins: Vec<Address> = vec![env, Address::generate(env)];
     let supported_msglibs: Vec<Address> = vec![env, Address::generate(env)];
     let price_feed: Address = Address::generate(env);

package/contracts/workers/dvn/src/tests/multisig/verify_signatures.rs

@@ -17,9 +17,7 @@ fn sorted_signatures(setup: &TestSetup, digest: &BytesN<32>) -> Vec<BytesN<65>>
         setup.key_pairs.iter().map(|kp| (kp.eth_address, kp.sign_bytes(&setup.env, digest))).collect();
     pairs.sort_by(|a, b| a.0.cmp(&b.0));
     let mut result: Vec<BytesN<65>> = vec![&setup.env];
-    for (_, sig) in pairs {
-        result.push_back(sig);
-    }
+    pairs.into_iter().for_each(|(_, sig)| result.push_back(sig));
     result
 }