@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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());
 }

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

@@ -1,9 +1,12 @@
-use crate::tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID};
-use crate::{dvn::LzDVN, errors::DvnError, storage::DvnStorage};
+use crate::{
+    dvn::LzDVN,
+    tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID},
+};
 use soroban_sdk::{
     testutils::{Address as _, AuthorizedFunction, BytesN as _},
     vec, Address, BytesN, Env, IntoVal, Symbol, Vec,
 };
+use utils::errors::MultisigError;
 
 fn random_signer(env: &Env) -> BytesN<20> {
     BytesN::random(env)
@@ -66,7 +69,7 @@ fn test_set_threshold_zero_fails() {
     let setup = TestSetup::new(1);
 
     let res = setup.multisig_client.try_set_threshold(&0);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::ZeroThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
 }
 
 #[test]
@@ -74,7 +77,7 @@ fn test_set_threshold_above_signers_fails() {
     let setup = TestSetup::new(2);
 
     let res = setup.multisig_client.try_set_threshold(&3);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
@@ -82,15 +85,15 @@ fn test_set_threshold_with_no_signers_fails() {
     let setup = TestSetup::new(1);
 
     setup.env.as_contract(&setup.contract_id, || {
-        DvnStorage::remove_signers(&setup.env);
+        utils::multisig::MultisigStorage::remove_signers(&setup.env);
     });
 
     let res = setup.multisig_client.try_set_threshold(&1);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #14)")] // DvnError::ZeroThreshold
+#[should_panic(expected = "Error(Contract, #1067)")] // ZeroThreshold
 fn test_constructor_threshold_zero_panics() {
     let env = Env::default();
     env.mock_all_auths();
@@ -99,7 +102,7 @@ fn test_constructor_threshold_zero_panics() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #12)")] // DvnError::TotalSignersLessThanThreshold
+#[should_panic(expected = "Error(Contract, #1065)")] // TotalSignersLessThanThreshold
 fn test_constructor_signers_less_than_threshold_panics() {
     let env = Env::default();
     env.mock_all_auths();

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

@@ -1,9 +1,8 @@
 extern crate std;
 
-use crate::storage::DvnStorage;
-use crate::tests::key_pair::KeyPair;
-use crate::tests::setup::TestSetup;
+use crate::tests::{key_pair::KeyPair, setup::TestSetup};
 use soroban_sdk::{vec, Bytes, BytesN, Vec};
+use utils::errors::MultisigError;
 
 fn hash(env: &soroban_sdk::Env, label: &[u8]) -> BytesN<32> {
     env.crypto().keccak256(&Bytes::from_slice(env, label)).to_bytes()
@@ -59,7 +58,6 @@ fn test_verify_signatures_raw_v_path() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11)")] // DvnError::SignerNotFound
 fn test_verify_signatures_with_wrong_signer() {
     let setup = TestSetup::new(1);
     let digest = hash(&setup.env, b"test");
@@ -67,22 +65,22 @@ fn test_verify_signatures_with_wrong_signer() {
     let signature = wrong_key_pair.sign(&digest.to_array());
     let signatures: Vec<BytesN<65>> = vec![&setup.env, BytesN::from_array(&setup.env, &signature)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #9)")] // DvnError::SignatureError
 fn test_verify_signatures_insufficient_signatures() {
     let setup = TestSetup::new(2);
     let digest = hash(&setup.env, b"insufficient");
 
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sign(&setup, 0, &digest)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignatureError.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #13)")] // DvnError::UnsortedSigners
 fn test_verify_signatures_duplicate_signer() {
     let setup = TestSetup::new(2);
     let digest = hash(&setup.env, b"duplicate");
@@ -90,20 +88,21 @@ fn test_verify_signatures_duplicate_signer() {
     let sig1 = sign(&setup, 0, &digest);
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sig1.clone(), sig1];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::UnsortedSigners.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #14)")] // DvnError::ZeroThreshold
 fn test_verify_signatures_threshold_zero() {
     let setup = TestSetup::new(1);
     // Force threshold to 0 via storage to hit ZeroThreshold branch
     setup.env.as_contract(&setup.contract_id, || {
-        DvnStorage::set_threshold(&setup.env, &0);
+        utils::multisig::MultisigStorage::set_threshold(&setup.env, &0);
     });
     let digest = hash(&setup.env, b"threshold_zero");
 
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sign(&setup, 0, &digest)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
 }

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

@@ -2,9 +2,9 @@
 
 extern crate std;
 
-use crate::tests::key_pair::KeyPair;
-use crate::{dvn::LzDVN, interfaces::MultiSigClient};
+use crate::{dvn::LzDVN, tests::key_pair::KeyPair};
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
+use utils::multisig::MultisigClient;
 use std::vec::Vec as StdVec;
 
 pub const VID: u32 = 1;
@@ -13,7 +13,7 @@ pub const DEFAULT_MULTIPLIER_BPS: u32 = 10000;
 pub struct TestSetup<'a> {
     pub env: Env,
     pub contract_id: Address,
-    pub multisig_client: MultiSigClient<'a>,
+    pub multisig_client: MultisigClient<'a>,
     pub key_pairs: StdVec<KeyPair>,
     pub admins: Vec<Address>,
 }
@@ -58,7 +58,7 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultiSigClient::new(&env, &contract_id);
+        let multisig_client = MultisigClient::new(&env, &contract_id);
 
         Self { env, contract_id, multisig_client, key_pairs, admins }
     }
@@ -102,7 +102,7 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultiSigClient::new(&env, &contract_id);
+        let multisig_client = MultisigClient::new(&env, &contract_id);
 
         Self { env, contract_id, multisig_client, key_pairs, admins }
     }

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

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

package/contracts/workers/dvn-fee-lib/src/dvn_fee_lib.rs

@@ -1,6 +1,6 @@
 use crate::errors::DvnFeeLibError;
-use common_macros::{contract_impl, ownable, ttl_configurable, upgradeable};
-use soroban_sdk::{assert_with_error, contract, Address, Env};
+use common_macros::{contract_impl, lz_contract};
+use soroban_sdk::{assert_with_error, Address, Env};
 use utils::upgradeable::UpgradeableInternal;
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
@@ -28,10 +28,7 @@ pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 /// Provides fee calculation logic based on quorum size, destination gas costs,
 /// and current gas prices from the price feed. Handles fee multipliers and
 /// floor margins.
-#[contract]
-#[ownable]
-#[ttl_configurable]
-#[upgradeable]
+#[lz_contract(upgradeable)]
 pub struct DvnFeeLib;
 
 #[contract_impl]