@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -5,15 +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};
+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::{contract, xdr::ToXdr, Address, Bytes, BytesN, Env, Vec};
-use utils::buffer_writer::BufferWriter;
-use utils::option_ext::OptionExt;
+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,
@@ -23,8 +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]
+#[lz_contract(multisig, upgradeable)]
 pub struct LzDVN;
 
 // ============================================================================
@@ -57,8 +55,8 @@ impl LzDVN {
         worker_fee_lib: &Address,
         deposit_address: &Address,
     ) {
-        Self::init_multisig(env, signers, threshold);
-        Self::init_owner(env, &env.current_contract_address());
+        ttl_configurable::init_default_ttl_configs(env);
+        multisig::init_multisig(env, signers, threshold);
         init_worker::<Self>(
             env,
             admins,
@@ -200,14 +198,25 @@ impl ILayerZeroDVN for LzDVN {
 // Worker Implementation
 // ============================================================================
 
+/// Worker trait implementation using default methods for pause, admin, ACL, and fee configuration.
 #[contract_impl(contracttrait)]
 impl Worker for LzDVN {}
 
 // ============================================================================
-// Include SubModules
+// 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;
-#[path = "multisig.rs"]
-pub mod multisig;

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

@@ -5,14 +5,8 @@ pub enum DvnError {
     AuthDataExpired,
     EidNotSupported,
     HashAlreadyUsed,
-    InvalidSigner,
+    InvalidInvocation,
     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, #13)")] // 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, #11)")] // 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, #10)")] // 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, #8)")] // 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, #12)")] // 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, #13)")] // 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

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

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

@@ -1,6 +1,7 @@
-use crate::DvnFeeLibError;
-use common_macros::contract_impl;
-use soroban_sdk::{assert_with_error, contract, Address, Env};
+use crate::errors::DvnFeeLibError;
+use common_macros::{contract_impl, lz_contract};
+use soroban_sdk::{assert_with_error, Address, Env};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
@@ -11,13 +12,13 @@ use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 pub(crate) const BPS_BASE: i128 = 10000;
 
 /// Fixed bytes for execute function call.
-pub(crate) const EXECUTE_FIXED_BYTES: u64 = 260;
+pub(crate) const EXECUTE_FIXED_BYTES: u32 = 260;
 
 /// Raw signature bytes length (65 bytes: 64 for signature + 1 for recovery ID).
-pub(crate) const SIGNATURE_RAW_BYTES: u64 = 65;
+pub(crate) const SIGNATURE_RAW_BYTES: u32 = 65;
 
 /// Verify function bytes (padded).
-pub(crate) const VERIFY_BYTES: u64 = 288;
+pub(crate) const VERIFY_BYTES: u32 = 288;
 
 /// Native token decimal rate for XLM (10^7 stroops per XLM).
 pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
@@ -27,30 +28,35 @@ 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]
+#[lz_contract(upgradeable)]
 pub struct DvnFeeLib;
 
+#[contract_impl]
+impl DvnFeeLib {
+    pub fn __constructor(env: &Env, owner: &Address) {
+        Self::init_owner(env, owner);
+    }
+}
+
 #[contract_impl]
 impl IDvnFeeLib for DvnFeeLib {
     fn get_fee(env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
-        assert_with_error!(env, params.gas > 0, DvnFeeLibError::InvalidGas);
+        assert_with_error!(env, params.gas != 0, DvnFeeLibError::EidNotSupported);
         assert_with_error!(env, params.options.is_empty(), DvnFeeLibError::InvalidDVNOptions);
 
-        let call_data_size = get_call_data_size(params.quorum as u64);
-        let call_data_size_u32 =
-            u32::try_from(call_data_size).expect("call data size should comfortably fit into u32 for WASM");
+        let call_data_size = get_call_data_size(params.quorum);
 
         // Get estimated fee from price feed
         let price_feed_client = LayerZeroPriceFeedClient::new(env, &params.price_feed);
         let fee_result = price_feed_client.estimate_fee_by_eid(
             &env.current_contract_address(),
             &params.dst_eid,
-            &call_data_size_u32,
+            &call_data_size,
             &params.gas,
         );
-        assert_with_error!(env, fee_result.total_gas_fee >= 0, DvnFeeLibError::NegativeFee);
 
         apply_premium(
+            env,
             fee_result.total_gas_fee,
             params.multiplier_bps,
             params.default_multiplier_bps,
@@ -60,6 +66,18 @@ impl IDvnFeeLib for DvnFeeLib {
     }
 }
 
+// ============================================================================
+// Upgradeable Implementation
+// ============================================================================
+
+impl UpgradeableInternal for DvnFeeLib {
+    type MigrationData = ();
+
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
+        // No migration logic needed for initial upgrade capability
+    }
+}
+
 // ============================================================================
 // Internal Helper Functions
 // ============================================================================
@@ -79,19 +97,24 @@ impl IDvnFeeLib for DvnFeeLib {
 /// # Returns
 /// Fee with premium applied (max of multiplier fee and margin fee).
 pub(crate) fn apply_premium(
+    env: &Env,
     fee: i128,
     multiplier_bps: u32,
     default_multiplier_bps: u32,
     floor_margin_usd: u128,
     native_price_usd: u128,
 ) -> i128 {
-    let effective_multiplier_bps = if multiplier_bps == 0 { default_multiplier_bps } else { multiplier_bps };
+    assert_with_error!(env, fee >= 0, DvnFeeLibError::InvalidFee);
 
+    let effective_multiplier_bps = if multiplier_bps == 0 { default_multiplier_bps } else { multiplier_bps };
     let fee_with_multiplier = fee * (effective_multiplier_bps as i128) / BPS_BASE;
     if native_price_usd == 0 || floor_margin_usd == 0 {
         return fee_with_multiplier;
     }
-    let fee_with_floor_margin = fee + (floor_margin_usd * NATIVE_DECIMALS_RATE / native_price_usd) as i128;
+
+    let floor_margin_in_native = safe_u128_to_i128(env, floor_margin_usd * NATIVE_DECIMALS_RATE / native_price_usd);
+    let fee_with_floor_margin = fee + floor_margin_in_native;
+
     fee_with_floor_margin.max(fee_with_multiplier)
 }
 
@@ -105,10 +128,16 @@ pub(crate) fn apply_premium(
 ///
 /// # Returns
 /// Total calldata size in bytes.
-pub(crate) fn get_call_data_size(quorum: u64) -> u64 {
+pub(crate) fn get_call_data_size(quorum: u32) -> u32 {
     let mut total_signature_bytes = quorum * SIGNATURE_RAW_BYTES;
     if !total_signature_bytes.is_multiple_of(32) {
         total_signature_bytes = total_signature_bytes - (total_signature_bytes % 32) + 32;
     }
     EXECUTE_FIXED_BYTES + VERIFY_BYTES + total_signature_bytes + 32
 }
+
+/// Safely converts u128 to i128, panicking if value exceeds i128::MAX.
+fn safe_u128_to_i128(env: &Env, value: u128) -> i128 {
+    assert_with_error!(env, value <= i128::MAX as u128, DvnFeeLibError::Overflow);
+    value as i128
+}

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

@@ -2,7 +2,8 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum DvnFeeLibError {
+    EidNotSupported,
     InvalidDVNOptions,
-    InvalidGas,
-    NegativeFee,
+    InvalidFee,
+    Overflow,
 }

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

@@ -1,17 +1,11 @@
 #![no_std]
-#[cfg(test)]
-extern crate std;
-
-mod errors;
 
-pub use errors::*;
+pub mod dvn_fee_lib;
+pub mod errors;
 
-cfg_if::cfg_if! {
-    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
-        mod dvn_fee_lib;
-        pub use dvn_fee_lib::DvnFeeLib;
-    }
-}
+pub use dvn_fee_lib::{DvnFeeLib, DvnFeeLibClient};
 
+#[cfg(test)]
+extern crate std;
 #[cfg(test)]
 mod tests;