@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -0,0 +1,109 @@
+extern crate std;
+
+use crate::storage::MultisigStorage;
+use crate::tests::key_pair::KeyPair;
+use crate::tests::setup::TestSetup;
+use soroban_sdk::{vec, Bytes, BytesN, Vec};
+
+fn hash(env: &soroban_sdk::Env, label: &[u8]) -> BytesN<32> {
+    env.crypto().keccak256(&Bytes::from_slice(env, label)).to_bytes()
+}
+
+fn sign(setup: &TestSetup, idx: usize, hash: &BytesN<32>) -> BytesN<65> {
+    setup.key_pairs[idx].sign_bytes(&setup.env, hash)
+}
+
+fn sorted_signatures(setup: &TestSetup, digest: &BytesN<32>) -> Vec<BytesN<65>> {
+    let mut pairs: std::vec::Vec<_> =
+        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);
+    }
+    result
+}
+
+#[test]
+fn test_verify_signatures() {
+    let setup = TestSetup::new(1);
+    let digest = hash(&setup.env, b"test");
+    let signature = setup.key_pairs[0].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);
+}
+
+#[test]
+fn test_verify_signatures_multiple_signers() {
+    let setup = TestSetup::new(2);
+    let digest = hash(&setup.env, b"multisig");
+
+    let signatures = sorted_signatures(&setup, &digest);
+
+    setup.multisig_client.verify_signatures(&digest, &signatures);
+}
+
+#[test]
+fn test_verify_signatures_raw_v_path() {
+    let setup = TestSetup::new(1);
+    let digest = hash(&setup.env, b"rawv");
+
+    // Sign normally (v in 27/28), then force v into raw 0/1 path
+    let mut sig_bytes = setup.key_pairs[0].sign(&digest.to_array());
+    sig_bytes[64] = sig_bytes[64].saturating_sub(27); // map 27->0 or 28->1
+    let signature = BytesN::from_array(&setup.env, &sig_bytes);
+    let signatures: Vec<BytesN<65>> = vec![&setup.env, signature];
+
+    setup.multisig_client.verify_signatures(&digest, &signatures);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #5)")] // MultisigError::SignerNotFound
+fn test_verify_signatures_with_wrong_signer() {
+    let setup = TestSetup::new(1);
+    let digest = hash(&setup.env, b"test");
+    let wrong_key_pair = KeyPair::generate();
+    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);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #7)")] // MultisigError::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);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #6)")] // MultisigError::UnsortedSigners
+fn test_verify_signatures_duplicate_signer() {
+    let setup = TestSetup::new(2);
+    let digest = hash(&setup.env, b"duplicate");
+
+    let sig1 = sign(&setup, 0, &digest);
+    let signatures: Vec<BytesN<65>> = vec![&setup.env, sig1.clone(), sig1];
+
+    setup.multisig_client.verify_signatures(&digest, &signatures);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1)")] // MultisigError::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, || {
+        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);
+}

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

@@ -0,0 +1,109 @@
+//! Test setup utilities for DVN tests
+
+extern crate std;
+
+use crate::tests::key_pair::KeyPair;
+use crate::{dvn::Dvn, interfaces::MultiSigClient};
+use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
+use std::vec::Vec as StdVec;
+
+pub const VID: u32 = 1;
+pub const DEFAULT_MULTIPLIER_BPS: u32 = 10000;
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub contract_id: Address,
+    pub multisig_client: MultiSigClient<'a>,
+    pub key_pairs: StdVec<KeyPair>,
+    pub admins: Vec<Address>,
+}
+
+impl<'a> TestSetup<'a> {
+    /// Create a new test setup with the specified number of signers
+    /// Threshold defaults to signer_count
+    pub fn new(signer_count: u32) -> Self {
+        Self::with_threshold(signer_count, signer_count)
+    }
+
+    /// Create a new test setup with custom threshold
+    pub fn with_threshold(signer_count: u32, threshold: u32) -> Self {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let key_pairs: StdVec<KeyPair> = (0..signer_count).map(|_| KeyPair::generate()).collect();
+
+        let mut signers: Vec<BytesN<20>> = vec![&env];
+        for kp in &key_pairs {
+            signers.push_back(kp.signer(&env));
+        }
+
+        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);
+        let worker_fee_lib: Address = Address::generate(&env);
+        let deposit_address: Address = Address::generate(&env);
+
+        let contract_id = env.register(
+            Dvn,
+            (
+                &VID,
+                &signers,
+                &threshold,
+                &admins,
+                &supported_msglibs,
+                &price_feed,
+                &worker_fee_lib,
+                &DEFAULT_MULTIPLIER_BPS,
+                &deposit_address,
+            ),
+        );
+
+        let multisig_client = MultiSigClient::new(&env, &contract_id);
+
+        Self { env, contract_id, multisig_client, key_pairs, admins }
+    }
+
+    /// Create a new test setup with additional admins (as Ed25519 public key bytes)
+    pub fn with_admin_bytes(signer_count: u32, admin_bytes: StdVec<[u8; 32]>) -> Self {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let key_pairs: StdVec<KeyPair> = (0..signer_count).map(|_| KeyPair::generate()).collect();
+
+        let mut signers: Vec<BytesN<20>> = vec![&env];
+        for kp in &key_pairs {
+            signers.push_back(kp.signer(&env));
+        }
+
+        let mut admins: Vec<Address> = vec![&env, Address::generate(&env)];
+        for bytes in admin_bytes {
+            let bytes_n = BytesN::from_array(&env, &bytes);
+            let addr = Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(bytes_n));
+            admins.push_back(addr);
+        }
+
+        let supported_msglibs: Vec<Address> = vec![&env, Address::generate(&env)];
+        let price_feed: Address = Address::generate(&env);
+        let worker_fee_lib: Address = Address::generate(&env);
+        let deposit_address: Address = Address::generate(&env);
+
+        let contract_id = env.register(
+            Dvn,
+            (
+                &VID,
+                &signers,
+                &signer_count,
+                &admins,
+                &supported_msglibs,
+                &price_feed,
+                &worker_fee_lib,
+                &DEFAULT_MULTIPLIER_BPS,
+                &deposit_address,
+            ),
+        );
+
+        let multisig_client = MultiSigClient::new(&env, &contract_id);
+
+        Self { env, contract_id, multisig_client, key_pairs, admins }
+    }
+}

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

@@ -0,0 +1,26 @@
+use soroban_sdk::{contracttype, BytesN, Vec};
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DstConfig {
+    pub gas: u128,
+    pub multiplier_bps: u32,
+    pub floor_margin_usd: u128,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DstConfigParam {
+    pub dst_eid: u32,
+    pub config: DstConfig,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct TransactionAuthData {
+    pub vid: u32,
+    pub expiration: u64,
+    pub signatures: Vec<BytesN<65>>,
+    pub admin: BytesN<32>,
+    pub admin_signature: BytesN<64>,
+}

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

@@ -0,0 +1,24 @@
+[package]
+name = "dvn-fee-lib"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[features]
+library = []
+testutils = []
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+doctest = false
+
+[dependencies]
+cfg-if = "1.0"
+soroban-sdk = { workspace = true }
+message-lib-common = { workspace = true }
+worker = { workspace = true }
+common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }

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

@@ -0,0 +1,113 @@
+use crate::DvnFeeLibError;
+use soroban_sdk::{assert_with_error, contract, contractimpl, Env};
+use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+/// Basis points denominator (10000 = 100%).
+pub(crate) const BPS_BASE: i128 = 10000;
+
+/// Fixed bytes for execute function call.
+pub(crate) const EXECUTE_FIXED_BYTES: u64 = 260;
+
+/// Raw signature bytes length (65 bytes: 64 for signature + 1 for recovery ID).
+pub(crate) const SIGNATURE_RAW_BYTES: u64 = 65;
+
+/// Verify function bytes (padded).
+pub(crate) const VERIFY_BYTES: u64 = 288;
+
+/// Native token decimal rate for XLM (10^7 stroops per XLM).
+pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
+
+/// DVN fee library contract for calculating DVN verification fees.
+///
+/// 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]
+pub struct DvnFeeLib;
+
+#[contractimpl]
+impl IDvnFeeLib for DvnFeeLib {
+    fn get_fee(env: &Env, params: &DvnFeeParams) -> i128 {
+        assert_with_error!(env, params.gas > 0, DvnFeeLibError::InvalidGas);
+        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");
+
+        // 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,
+            &params.gas,
+        );
+        assert_with_error!(env, fee_result.total_gas_fee >= 0, DvnFeeLibError::NegativeFee);
+
+        apply_premium(
+            fee_result.total_gas_fee,
+            params.multiplier_bps,
+            params.default_multiplier_bps,
+            params.floor_margin_usd,
+            fee_result.native_price_usd,
+        )
+    }
+}
+
+// ============================================================================
+// Internal Helper Functions
+// ============================================================================
+
+/// Applies premium (multiplier and margin) to the base fee.
+///
+/// Calculates fee with multiplier and floor margin, returning the maximum of both
+/// to ensure profitability.
+///
+/// # Arguments
+/// * `fee` - Base gas fee
+/// * `multiplier_bps` - Destination-specific multiplier in basis points
+/// * `default_multiplier_bps` - Default multiplier if destination multiplier is 0
+/// * `floor_margin_usd` - Minimum margin in USD (scaled)
+/// * `native_price_usd` - Native token price in USD (scaled)
+///
+/// # Returns
+/// Fee with premium applied (max of multiplier fee and margin fee).
+pub(crate) fn apply_premium(
+    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 };
+
+    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;
+    fee_with_floor_margin.max(fee_with_multiplier)
+}
+
+/// Calculates the total calldata size for DVN verification.
+///
+/// Includes execute function overhead, verify function bytes, and padded signature bytes.
+/// Signature bytes are padded to 32-byte boundaries for efficient EVM processing.
+///
+/// # Arguments
+/// * `quorum` - Number of signatures required
+///
+/// # Returns
+/// Total calldata size in bytes.
+pub(crate) fn get_call_data_size(quorum: u64) -> u64 {
+    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
+}

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

@@ -0,0 +1,8 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum DvnFeeLibError {
+    InvalidDVNOptions,
+    InvalidGas,
+    NegativeFee,
+}

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

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

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

@@ -0,0 +1,282 @@
+use crate::dvn_fee_lib::{
+    apply_premium, get_call_data_size, DvnFeeLib, BPS_BASE, EXECUTE_FIXED_BYTES, NATIVE_DECIMALS_RATE, VERIFY_BYTES,
+};
+use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Bytes, Env};
+use worker::{interfaces::FeeEstimate, DvnFeeParams, IDvnFeeLib};
+
+#[test]
+fn get_call_data_size_pads_signatures() {
+    let size = get_call_data_size(1);
+    assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 96 + 32);
+
+    let size = get_call_data_size(2);
+    assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 160 + 32);
+
+    let size = get_call_data_size(32);
+    assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 2080 + 32);
+}
+
+#[test]
+fn apply_premium_multiplier_only_both_zero() {
+    let fee = 1_000i128;
+    let multiplier_bps = 15_000u32;
+    // multiplier_bps is non-zero, so default_multiplier_bps is ignored
+    let result = apply_premium(fee, multiplier_bps, 10_000, 0, 0);
+    assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
+}
+
+#[test]
+fn apply_premium_multiplier_only_native_price_zero() {
+    let fee = 1_000i128;
+    let multiplier_bps = 15_000u32;
+    let result = apply_premium(fee, multiplier_bps, 10_000, 100, 0);
+    assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
+}
+
+#[test]
+fn apply_premium_multiplier_only_floor_margin_zero() {
+    let fee = 1_000i128;
+    let multiplier_bps = 15_000u32;
+    let result = apply_premium(fee, multiplier_bps, 10_000, 0, NATIVE_DECIMALS_RATE);
+    assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
+}
+
+#[test]
+fn apply_premium_uses_default_when_multiplier_zero() {
+    let fee = 1_000i128;
+    let default_bps = 12_000u32;
+    // multiplier_bps is 0, so default_multiplier_bps should be used
+    let result = apply_premium(fee, 0, default_bps, 0, 0);
+    assert_eq!(result, fee * default_bps as i128 / BPS_BASE);
+}
+
+#[test]
+fn apply_premium_floor_margin_wins() {
+    let fee = 1_000i128;
+    let multiplier_bps = 10_000u32;
+    let floor_margin_usd = 10u128;
+    let native_price_usd = NATIVE_DECIMALS_RATE;
+
+    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    assert_eq!(result, fee + floor_margin_usd as i128);
+}
+
+#[test]
+fn apply_premium_multiplier_wins_over_small_floor() {
+    let fee = 1_000i128;
+    let multiplier_bps = 12_000u32;
+    let floor_margin_usd = 1u128;
+    let native_price_usd = NATIVE_DECIMALS_RATE;
+
+    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    assert_eq!(result, 1_200);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #2)")] // DvnFeeLibError::InvalidGas
+fn get_fee_panics_when_gas_zero() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 1,
+        confirmations: 1,
+        options: Bytes::new(&env),
+        price_feed: Address::generate(&env),
+        default_multiplier_bps: 10_000,
+        quorum: 1,
+        gas: 0, // Zero gas should panic
+        multiplier_bps: 10_000,
+        floor_margin_usd: 0,
+    };
+
+    DvnFeeLib::get_fee(&env, &params);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1)")] // DvnFeeLibError::InvalidDVNOptions
+fn get_fee_panics_when_options_not_empty() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let mut options = Bytes::new(&env);
+    options.push_back(1u8);
+
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 1,
+        confirmations: 1,
+        options, // Non-empty options should panic
+        price_feed: Address::generate(&env),
+        default_multiplier_bps: 10_000,
+        quorum: 1,
+        gas: 1,
+        multiplier_bps: 10_000,
+        floor_margin_usd: 0,
+    };
+
+    DvnFeeLib::get_fee(&env, &params);
+}
+
+#[contract]
+struct MockPriceFeed;
+
+#[contractimpl]
+impl MockPriceFeed {
+    pub fn estimate_fee_by_eid(
+        _env: &Env,
+        _fee_lib: &Address,
+        _dst_eid: u32,
+        _calldata_size: u32,
+        _gas: u128,
+    ) -> FeeEstimate {
+        FeeEstimate {
+            total_gas_fee: 100,
+            price_ratio: 0,
+            price_ratio_denominator: 0,
+            native_price_usd: NATIVE_DECIMALS_RATE,
+        }
+    }
+
+    pub fn native_token_price_usd(_env: &Env) -> u128 {
+        NATIVE_DECIMALS_RATE
+    }
+
+    pub fn set_native_token_price_usd(_env: &Env, _price_updater: &Address, _native_token_price_usd: u128) {}
+}
+
+#[contract]
+struct MockPriceFeedNegative;
+
+#[contractimpl]
+impl MockPriceFeedNegative {
+    pub fn estimate_fee_by_eid(
+        _env: &Env,
+        _fee_lib: &Address,
+        _dst_eid: u32,
+        _calldata_size: u32,
+        _gas: u128,
+    ) -> FeeEstimate {
+        FeeEstimate {
+            total_gas_fee: -100,
+            price_ratio: 0,
+            price_ratio_denominator: 0,
+            native_price_usd: NATIVE_DECIMALS_RATE,
+        }
+    }
+}
+
+#[test]
+fn get_fee_success_path() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 7,
+        confirmations: 1,
+        options: Bytes::new(&env),
+        price_feed: env.register(MockPriceFeed, ()),
+        default_multiplier_bps: 10_000,
+        quorum: 2,
+        gas: 100,
+        multiplier_bps: 10_000,
+        floor_margin_usd: 0,
+    };
+
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+
+    assert_eq!(fee, 100);
+}
+
+#[test]
+fn get_fee_uses_default_multiplier_when_zero() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
+
+    // multiplier_bps = 0, default_multiplier_bps = 12000 (1.2x)
+    // MockPriceFeed returns fee=100, so result = 100 * 12000 / 10000 = 120
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 7,
+        confirmations: 1,
+        options: Bytes::new(&env),
+        price_feed: env.register(MockPriceFeed, ()),
+        default_multiplier_bps: 12_000,
+        quorum: 2,
+        gas: 100,
+        multiplier_bps: 0, // Zero means use default
+        floor_margin_usd: 0,
+    };
+
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+
+    assert_eq!(fee, 120);
+}
+
+#[test]
+fn get_fee_prefers_dst_multiplier_over_default() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
+
+    // multiplier_bps = 15000 (1.5x), default_multiplier_bps = 10000 (1.0x)
+    // MockPriceFeed returns fee=100, so result = 100 * 15000 / 10000 = 150
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 7,
+        confirmations: 1,
+        options: Bytes::new(&env),
+        price_feed: env.register(MockPriceFeed, ()),
+        default_multiplier_bps: 10_000,
+        quorum: 2,
+        gas: 100,
+        multiplier_bps: 15_000, // Prefer this over default
+        floor_margin_usd: 0,
+    };
+
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+
+    assert_eq!(fee, 150);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #3)")] // DvnFeeLibError::NegativeFee
+fn get_fee_panics_when_price_feed_returns_negative_fee() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let params = DvnFeeParams {
+        sender: Address::generate(&env),
+        dst_eid: 7,
+        confirmations: 1,
+        options: Bytes::new(&env),
+        price_feed: env.register(MockPriceFeedNegative, ()),
+        default_multiplier_bps: 10_000,
+        quorum: 2,
+        gas: 100,
+        multiplier_bps: 10_000,
+        floor_margin_usd: 0,
+    };
+
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+}
+
+#[test]
+#[should_panic]
+fn apply_premium_panics_on_overflow() {
+    let fee = i128::MAX / 2;
+    let multiplier_bps = 20_000u32;
+    apply_premium(fee, multiplier_bps, 10_000, u128::MAX, 1);
+}
+
+#[test]
+fn apply_premium_floor_margin_truncates() {
+    let fee = 0i128;
+    let multiplier_bps = 10_000u32;
+    let floor_margin_usd = 1u128;
+    let native_price_usd = NATIVE_DECIMALS_RATE * 3 / 2;
+
+    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    assert_eq!(result, 0);
+}

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

@@ -0,0 +1 @@
+mod dvn_fee_lib;