@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -1,9 +1,6 @@
+use crate::{errors::OwnableError, option_ext::OptionExt, tests::test_helper::assert_panics_contains};
 use soroban_sdk::Env;
 
-use crate::{errors::OwnableError, option_ext::OptionExt};
-
-use crate::tests::test_helper::assert_panics_contains;
-
 #[test]
 fn unwrap_or_panic_some_returns_value() {
     let env = Env::default();
@@ -13,7 +10,7 @@ fn unwrap_or_panic_some_returns_value() {
 
 #[test]
 fn unwrap_or_panic_none_panics_with_error() {
-    const EXPECTED: &str = "Error(Contract, #1301)";
+    const EXPECTED: &str = "Error(Contract, #1031)"; // OwnerNotSet
     assert_panics_contains("none unwrap_or_panic", EXPECTED, || {
         let env = Env::default();
         let _got: u32 = None::<u32>.unwrap_or_panic(&env, OwnableError::OwnerNotSet);

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

@@ -1,4 +1,7 @@
 use crate::{
+    auth::Auth,
+    errors::OwnableError,
+    option_ext::OptionExt,
     ownable::{self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred},
     testing_utils::assert_event,
 };
@@ -35,6 +38,14 @@ impl Contract {
     }
 }
 
+/// Auth implementation for the test contract - uses stored owner as authorizer.
+#[contractimpl]
+impl Auth for Contract {
+    fn authorizer(env: &Env) -> Address {
+        <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
+    }
+}
+
 #[contractimpl(contracttrait)]
 impl Ownable for Contract {}
 impl OwnableInitializer for Contract {}
@@ -76,7 +87,7 @@ fn auth_non_owner_cannot_call() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn auth_require_owner_when_no_owner_set() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -154,7 +165,7 @@ fn transfer_ownership_to_same_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn transfer_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -218,7 +229,7 @@ fn renounce_ownership_with_event() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn renounce_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -297,7 +308,7 @@ fn chain_new_owner_can_transfer() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1300)")]
+#[should_panic(expected = "Error(Contract, #1030)")] // OwnerAlreadySet
 fn reinit_owner_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -334,7 +345,7 @@ fn enforce_owner_auth_returns_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn enforce_owner_auth_no_owner_set_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);

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

@@ -1,10 +1,14 @@
 extern crate std;
 
-use crate::errors::TtlConfigurableError;
-use crate::ownable::OwnableInitializer;
-use crate::testing_utils::assert_event;
-use crate::ttl_configurable::{
-    TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
+use crate::{
+    auth::Auth,
+    errors::{OwnableError, TtlConfigurableError},
+    option_ext::OptionExt,
+    ownable::{Ownable, OwnableInitializer},
+    testing_utils::assert_event,
+    ttl_configurable::{
+        TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
+    },
 };
 use soroban_sdk::{
     contract, contractimpl,
@@ -90,11 +94,18 @@ impl TtlTestContract {
     }
 }
 
-// Enable the default `TtlConfigurable` implementation (which requires `Ownable`) on the test contract.
+// Enable the default `TtlConfigurable` implementation (which requires `Auth`) on the test contract.
 //
 // Note: use plain Rust `impl` (not `#[contractimpl(contracttrait)]`) to avoid generating
-// duplicate Soroban contract entrypoints that would collide with this test contract’s helpers.
-impl crate::ownable::Ownable for TtlTestContract {}
+// duplicate Soroban contract entrypoints that would collide with this test contract's helpers.
+
+/// Auth implementation for test contract - uses the stored owner as authorizer.
+impl Auth for TtlTestContract {
+    fn authorizer(env: &soroban_sdk::Env) -> Address {
+        <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
+    }
+}
+impl Ownable for TtlTestContract {}
 impl OwnableInitializer for TtlTestContract {}
 impl TtlConfigurable for TtlTestContract {}
 
@@ -369,7 +380,7 @@ fn test_default_ttl_configurable_freeze() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1201)")]
+#[should_panic(expected = "Error(Contract, #1021)")] // TtlConfigFrozen
 fn test_default_ttl_configurable_set_when_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -382,7 +393,7 @@ fn test_default_ttl_configurable_set_when_frozen() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1202)")]
+#[should_panic(expected = "Error(Contract, #1022)")] // TtlConfigAlreadyFrozen
 fn test_default_ttl_configurable_freeze_when_already_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -412,7 +423,7 @@ fn test_default_ttl_configurable_freeze_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn test_default_ttl_configurable_freeze_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -430,7 +441,7 @@ fn test_default_ttl_configurable_freeze_when_owner_not_set() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_instance_config() {
     let (env, contract_id, owner, client) = setup_contract();
     // threshold > extend_to is invalid
@@ -441,7 +452,7 @@ fn test_default_ttl_configurable_invalid_instance_config() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_persistent_config() {
     let (env, contract_id, owner, client) = setup_contract();
     let invalid_cfg = TtlConfig::new(5000, 4000);
@@ -451,7 +462,7 @@ fn test_default_ttl_configurable_invalid_persistent_config() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_exceeds_max_ttl() {
     let (env, contract_id, owner, client) = setup_contract();
     let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
@@ -518,7 +529,7 @@ fn test_default_ttl_configurable_set_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn test_default_ttl_configurable_set_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -534,7 +545,7 @@ fn test_default_ttl_configurable_set_when_owner_not_set() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_exceeds_effective_max_ttl() {
     let (env, contract_id, owner, client) = setup_contract();
 

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

@@ -256,7 +256,7 @@ fn test_migrate_success() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1500)")]
+#[should_panic(expected = "Error(Contract, #1050)")] // MigrationNotAllowed
 fn test_migrate_fail_without_upgrade() {
     let env = Env::default();
     let contract_id = env.register(DummyContract, ());
@@ -271,14 +271,16 @@ fn test_migrate_fail_without_upgrade() {
 // Integration test: upgrade then migrate
 // ============================================
 
+// TODO (ken): change error code to 1050 and fix test
 #[test]
-#[should_panic(expected = "Error(Contract, #1500)")]
+#[should_panic(expected = "Error(Contract, #1500)")] // MigrationNotAllowed (TEST_WASM uses old error code)
 fn test_cannot_migrate_twice_without_upgrade() {
     let env = Env::default();
     let contract_id = env.register(DummyContract, ());
     let client = DummyContractClient::new(&env, &contract_id);
 
     // First upgrade and migrate with valid WASM
+    // Note: TEST_WASM is a pre-compiled contract with old error codes (1500 instead of 1050)
     let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_WASM));
     client.upgrade(&wasm_hash);
     client.migrate(&());

package/contracts/utils/src/ttl_configurable.rs

@@ -1,8 +1,10 @@
 use crate::{
+    self as utils,
+    auth::{require_auth, Auth},
     errors::TtlConfigurableError,
-    ownable::{require_owner_auth, Ownable},
 };
-use soroban_sdk::{assert_with_error, contractevent, contracttrait, contracttype, Env};
+use common_macros::contract_trait;
+use soroban_sdk::{assert_with_error, contractevent, contracttype, Env};
 
 /// Ledgers per day (~5 second close time).
 pub const LEDGERS_PER_DAY: u32 = (24 * 3600) / 5;
@@ -75,15 +77,28 @@ pub enum TtlConfigStorage {
     Persistent,
 }
 
+/// Initializes TTL configs with the default values (threshold: 29 days, extend_to: 30 days).
+///
+/// This sets both instance and persistent TTL configs to `DEFAULT_TTL_CONFIG`.
+pub fn init_default_ttl_configs(env: &Env) {
+    let default_ttl_config = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+    TtlConfigStorage::set_instance(env, &default_ttl_config);
+    TtlConfigStorage::set_persistent(env, &default_ttl_config);
+}
+
 /// Trait for contracts that support configurable TTL (Time-To-Live) management.
 ///
-/// Allows the contract owner to configure how long instance and persistent storage entries
+/// Allows the contract authorizer to configure how long instance and persistent storage entries
 /// remain alive on Stellar.
 ///
-/// The owner can also permanently freeze the configuration to prevent future changes,
+/// The authorizer can also permanently freeze the configuration to prevent future changes,
 /// providing immutability guarantees to users.
-#[contracttrait]
-pub trait TtlConfigurable: Ownable {
+///
+/// Requires the `Auth` trait to be implemented, which can be provided by either:
+/// - `#[ownable]` macro for single-owner contracts
+/// - `Multisig` trait for multisig-controlled contracts
+#[contract_trait]
+pub trait TtlConfigurable: Auth {
     /// Sets TTL configs for instance and persistent storage.
     ///
     /// - `None` values remove the corresponding config (disables auto-extension for that type)
@@ -97,7 +112,7 @@ pub trait TtlConfigurable: Ownable {
     /// - `TtlConfigFrozen` if configs are frozen
     /// - `InvalidTtlConfig` if validation fails
     fn set_ttl_configs(env: &Env, instance: &Option<TtlConfig>, persistent: &Option<TtlConfig>) {
-        require_owner_auth::<Self>(env);
+        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());
@@ -123,7 +138,7 @@ pub trait TtlConfigurable: Ownable {
     /// # Panics
     /// - `TtlConfigAlreadyFrozen` if already frozen
     fn freeze_ttl_configs(env: &Env) {
-        require_owner_auth::<Self>(env);
+        require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlConfigurableError::TtlConfigAlreadyFrozen);
 
         TtlConfigStorage::set_frozen(env, &true);

package/contracts/utils/src/ttl_extendable.rs

@@ -0,0 +1,27 @@
+//! TtlExtendable trait for manual instance TTL extension.
+//!
+//! This module provides the `TtlExtendable` trait which allows external callers
+//! to extend a contract's instance storage TTL, keeping the contract alive.
+
+use soroban_sdk::Env;
+
+/// Trait for contracts that support manual instance TTL extension.
+///
+/// This trait provides a public contract function to extend the instance storage TTL,
+/// allowing external callers to keep the contract alive by paying for TTL extension.
+///
+/// Uses `#[soroban_sdk::contracttrait]` directly (not `#[common_macros::contract_trait]`)
+/// because auto TTL extension would be redundant for a trait whose purpose is manual
+/// TTL control.
+#[soroban_sdk::contracttrait]
+pub trait TtlExtendable {
+    /// Extends the instance TTL.
+    ///
+    /// # Arguments
+    ///
+    /// * `threshold` - The threshold to extend the TTL (if current TTL is below this, extend).
+    /// * `extend_to` - The TTL to extend to.
+    fn extend_instance_ttl(env: &Env, threshold: u32, extend_to: u32) {
+        env.storage().instance().extend_ttl(threshold, extend_to);
+    }
+}

package/contracts/utils/src/upgradeable.rs

@@ -52,3 +52,5 @@ pub fn migrate<T: UpgradeableInternal>(env: &Env, migration_data: &T::MigrationD
     UpgradeableStorage::set_migrating(env, &false);
     T::__migrate(env, migration_data);
 }
+
+// TODO (hanson): review and polish this

package/contracts/workers/dvn/Cargo.toml

@@ -10,7 +10,7 @@ library = []
 testutils = []
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]

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

@@ -1,9 +1,8 @@
 use super::*;
-
 use soroban_sdk::{
     address_payload::AddressPayload,
     auth::{Context, CustomAccountInterface},
-    contractimpl, contracttype,
+    contracttype,
     crypto::Hash,
     vec, Symbol,
 };
@@ -43,7 +42,7 @@ pub struct TransactionAuthData {
 // Custom Account Interface Implementation
 // ============================================================================
 
-#[contractimpl]
+#[contract_impl]
 impl CustomAccountInterface for LzDVN {
     type Signature = TransactionAuthData;
     type Error = DvnError;
@@ -125,9 +124,10 @@ impl LzDVN {
     ///
     /// 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 {
-        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")
-        })
+        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")
+            })
     }
 }

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

@@ -5,17 +5,14 @@
 //! signatures for authorization and implements Soroban's custom account
 //! interface for transaction signing.
 
-use crate::{
-    errors::DvnError, events::SetDstConfig, storage::DvnStorage, Call, DstConfig, DstConfigParam, IMultisig, IDVN,
-};
-use common_macros::{contract_impl, ttl_configurable, upgradeable};
+use crate::{errors::DvnError, events::SetDstConfig, storage::DvnStorage, Call, DstConfig, DstConfigParam, IDVN};
+use common_macros::{contract_impl, lz_contract};
 use endpoint_v2::FeeRecipient;
 use message_lib_common::interfaces::ILayerZeroDVN;
-use soroban_sdk::panic_with_error;
-use soroban_sdk::{contract, xdr::ToXdr, Address, Bytes, BytesN, Env, Vec};
-use utils::option_ext::OptionExt;
-use utils::{buffer_writer::BufferWriter, ownable::Ownable};
-use utils::upgradeable::UpgradeableInternal;
+use soroban_sdk::{xdr::ToXdr, Address, Bytes, BytesN, Env, Vec};
+use utils::{
+    buffer_writer::BufferWriter, multisig, option_ext::OptionExt, ttl_configurable, upgradeable::UpgradeableInternal,
+};
 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,
@@ -25,9 +22,7 @@ use worker::{
 ///
 /// Implements multisig-based verification with custom account authorization.
 /// The contract owns itself, allowing the multisig quorum to authorize operations.
-#[contract]
-#[ttl_configurable]
-#[upgradeable]
+#[lz_contract(multisig, upgradeable)]
 pub struct LzDVN;
 
 // ============================================================================
@@ -60,7 +55,8 @@ impl LzDVN {
         worker_fee_lib: &Address,
         deposit_address: &Address,
     ) {
-        Self::init_multisig(env, signers, threshold);
+        ttl_configurable::init_default_ttl_configs(env);
+        multisig::init_multisig(env, signers, threshold);
         init_worker::<Self>(
             env,
             admins,
@@ -219,32 +215,8 @@ impl UpgradeableInternal for LzDVN {
 }
 
 // ============================================================================
-// Ownable impl for LzDVN
-// ============================================================================
-
-/// Self-owning contract: the DVN owns itself.
-///
-/// This allows multisig quorum approval to serve as owner authorization.
-/// Ownership transfer and renouncement are disabled since the contract is self-owned.
-impl Ownable for LzDVN {
-    fn owner(env: &Env) -> Option<Address> {
-        Some(env.current_contract_address())
-    }
-
-    fn transfer_ownership(env: &Env, _new_owner: &Address) {
-        panic_with_error!(env, DvnError::InvalidInvocation);
-    }
-
-    fn renounce_ownership(env: &Env) {
-        panic_with_error!(env, DvnError::InvalidInvocation);
-    }
-}
-
-// ============================================================================
-// Include SubModules
+// Include Auth Module
 // ============================================================================
 
 #[path = "auth.rs"]
 pub mod auth;
-#[path = "multisig.rs"]
-pub mod multisig;

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

@@ -6,14 +6,7 @@ pub enum DvnError {
     EidNotSupported,
     HashAlreadyUsed,
     InvalidInvocation,
-    InvalidSigner,
     InvalidVid,
     NonContractInvoke,
     OnlyAdmin,
-    SignatureError,
-    SignerAlreadyExists,
-    SignerNotFound,
-    TotalSignersLessThanThreshold,
-    UnsortedSigners,
-    ZeroThreshold,
 }

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

@@ -1,18 +1,5 @@
 use crate::DstConfigParam;
-use soroban_sdk::{contractevent, BytesN, Vec};
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct SignerSet {
-    pub signer: BytesN<20>,
-    pub active: bool,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ThresholdSet {
-    pub threshold: u32,
-}
+use soroban_sdk::{contractevent, Vec};
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]

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

@@ -1,6 +1,6 @@
-use crate::IMultisig;
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{contractclient, contracttype, Address, BytesN, Env, Symbol, Val, Vec};
+use utils::multisig::Multisig;
 use worker::Worker;
 
 /// Configuration for a destination chain.
@@ -47,7 +47,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 + IMultisig {
+pub trait IDVN: ILayerZeroDVN + Worker + Multisig {
     /// Sets the configuration for one or more destination chains.
     ///
     /// # Arguments

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

@@ -1,5 +1,3 @@
 mod dvn;
-mod multisig;
 
 pub use dvn::*;
-pub use multisig::*;

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

@@ -1,22 +1,12 @@
 use crate::DstConfig;
 use common_macros::storage;
-use soroban_sdk::{BytesN, Vec};
+use soroban_sdk::BytesN;
 
 /// DVN contract storage keys.
+///
+/// Note: Multisig storage (Signers, Threshold) is provided by `utils::multisig::MultisigStorage`.
 #[storage]
 pub enum DvnStorage {
-    // ======================== Multisig ========================
-    /// List of authorized signer addresses (20-byte Ethereum addresses).
-    #[persistent(Vec<BytesN<20>>)]
-    #[default(Vec::new(env))]
-    Signers,
-
-    /// Minimum number of signatures required for multisig operations.
-    #[instance(u32)]
-    #[default(0)]
-    Threshold,
-
-    // ======================== DVN ============================
     /// Verifier ID - unique identifier for this DVN instance.
     #[instance(u32)]
     Vid,

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

@@ -1,7 +1,7 @@
-use crate::tests::setup::{TestSetup, VID};
 use crate::{
     dvn::auth::{Sender, TransactionAuthData},
     errors::DvnError,
+    tests::setup::{TestSetup, VID},
 };
 use ed25519_dalek::{Signer, SigningKey};
 use rand::thread_rng;
@@ -134,15 +134,15 @@ fn test_check_auth_wrong_signer_fails() {
         sender: Sender::Admin(public_key, signature),
     };
 
-    // verify_signatures panics with DvnError::SignerNotFound when signer is not found
-    let res = env.try_invoke_contract_check_auth::<DvnError>(
+    // 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(DvnError::SignerNotFound)));
+    assert_eq!(res, Err(Ok(utils::errors::MultisigError::SignerNotFound)));
 }
 
 #[test]

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

@@ -1,5 +1,4 @@
-use crate::tests::setup::TestSetup;
-use crate::{dvn::LzDVN, DVNClient, DstConfig, DstConfigParam, IDVN};
+use crate::{dvn::LzDVN, tests::setup::TestSetup, DVNClient, DstConfig, DstConfigParam, IDVN};
 use endpoint_v2::FeeRecipient;
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{

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

@@ -1,10 +1,9 @@
-use crate::errors::DvnError;
-use crate::storage::DvnStorage;
 use crate::tests::setup::TestSetup;
 use soroban_sdk::{
     testutils::{AuthorizedFunction, BytesN as _},
     BytesN, Env, IntoVal, Symbol,
 };
+use utils::errors::MultisigError;
 
 fn random_signer(env: &Env) -> BytesN<20> {
     BytesN::random(env)
@@ -12,7 +11,7 @@ fn random_signer(env: &Env) -> BytesN<20> {
 
 fn clear_signers(setup: &TestSetup) {
     setup.env.as_contract(&setup.contract_id, || {
-        DvnStorage::remove_signers(&setup.env);
+        utils::multisig::MultisigStorage::remove_signers(&setup.env);
     });
 }
 
@@ -48,7 +47,7 @@ fn test_set_signer_duplicate_fails() {
     setup.multisig_client.set_signer(&signer, &true);
     let res = setup.multisig_client.try_set_signer(&signer, &true);
 
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerAlreadyExists.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerAlreadyExists.into());
 }
 
 #[test]
@@ -69,7 +68,7 @@ fn test_set_signer_remove_not_found() {
     let signer = random_signer(&setup.env);
 
     let res = setup.multisig_client.try_set_signer(&signer, &false);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
 }
 
 #[test]
@@ -78,7 +77,7 @@ fn test_set_signer_invalid_signer_zero_address() {
     let zero = BytesN::from_array(&setup.env, &[0u8; 20]);
 
     let res = setup.multisig_client.try_set_signer(&zero, &true);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::InvalidSigner.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::InvalidSigner.into());
 }
 
 #[test]
@@ -115,7 +114,7 @@ fn test_remove_signer_when_no_signers() {
 
     let signer = random_signer(&setup.env);
     let res = setup.multisig_client.try_set_signer(&signer, &false);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
 }
 
 #[test]
@@ -129,5 +128,5 @@ fn test_remove_signer_violates_threshold() {
 
     // Removing a signer should fail because it would leave only 1 signer with threshold 2
     let res = setup.multisig_client.try_set_signer(&signer_to_remove, &false);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
 }