@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.12

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

@@ -1,5 +1,5 @@
 use crate::tests::setup::TestSetup;
-use crate::{dvn::Dvn, DVNClient, DstConfig, DstConfigParam, IDVN};
+use crate::{dvn::LzDVN, DVNClient, DstConfig, DstConfigParam, IDVN};
 use endpoint_v2::FeeRecipient;
 use message_lib_common::interfaces::ILayerZeroDVN;
 use soroban_sdk::{
@@ -22,7 +22,7 @@ fn new_addr(env: &Env) -> Address {
 
 fn grant_allowlist(setup: &TestSetup, oapp: &Address) {
     with_contract(setup, || {
-        Dvn::set_allowlist(&setup.env, oapp, true);
+        LzDVN::set_allowlist(&setup.env, oapp, true);
     });
 }
 
@@ -30,17 +30,17 @@ fn configure_dst_config(setup: &TestSetup, dst_eid: u32, config: DstConfig) {
     let admin = setup.admins.get(0).unwrap();
     let params = vec![&setup.env, DstConfigParam { dst_eid, config }];
     with_contract(setup, || {
-        Dvn::set_dst_config(&setup.env, &admin, &params);
+        LzDVN::set_dst_config(&setup.env, &admin, &params);
     });
 }
 
 fn configure_fee_lib(setup: &TestSetup, fee_lib: &Address, default_multiplier: u32) {
     let admin = setup.admins.get(0).unwrap();
     with_contract(setup, || {
-        Dvn::set_worker_fee_lib(&setup.env, &admin, fee_lib);
+        LzDVN::set_worker_fee_lib(&setup.env, &admin, fee_lib);
     });
     with_contract(setup, || {
-        Dvn::set_default_multiplier_bps(&setup.env, &admin, default_multiplier);
+        LzDVN::set_default_multiplier_bps(&setup.env, &admin, default_multiplier);
     });
 }
 
@@ -52,15 +52,14 @@ fn test_vid_returns_configured_value() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #5)")] // DvnError::EidNotSupported
-fn test_dst_config_not_set_panics() {
+fn test_dst_config_not_set_returns_none() {
     let setup = TestSetup::new(1);
     let client = DVNClient::new(&setup.env, &setup.contract_id);
-    client.dst_config(&999);
+    assert_eq!(client.dst_config(&999), None);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #5)")] // DvnError::EidNotSupported
+#[should_panic(expected = "Error(Contract, #2)")] // DvnError::EidNotSupported
 fn test_get_fee_missing_dst_config_panics() {
     let setup = TestSetup::new(1);
     let send_lib = new_addr(&setup.env);
@@ -70,7 +69,7 @@ fn test_get_fee_missing_dst_config_panics() {
     let options = Bytes::new(&setup.env);
 
     with_contract(&setup, || {
-        Dvn::get_fee(&setup.env, &send_lib, &sender, 999, &packet_header, &payload_hash, 1, &options);
+        LzDVN::get_fee(&setup.env, &send_lib, &sender, 999, &packet_header, &payload_hash, 1, &options);
     });
 }
 
@@ -88,7 +87,7 @@ fn test_get_fee_not_allowed_due_to_allowlist() {
     let options = Bytes::new(&setup.env);
 
     with_contract(&setup, || {
-        Dvn::get_fee(&setup.env, &send_lib, &sender, 1, &packet_header, &payload_hash, 1, &options);
+        LzDVN::get_fee(&setup.env, &send_lib, &sender, 1, &packet_header, &payload_hash, 1, &options);
     });
 }
 
@@ -100,7 +99,7 @@ fn test_get_fee_uses_default_multiplier_when_dst_multiplier_zero() {
     configure_dst_config(&setup, 42, DstConfig { gas: 1, multiplier_bps: 0, floor_margin_usd: 0 });
 
     let fee = with_contract(&setup, || {
-        Dvn::get_fee(
+        LzDVN::get_fee(
             &setup.env,
             &new_addr(&setup.env),
             &new_addr(&setup.env),
@@ -123,7 +122,7 @@ fn test_get_fee_prefers_dst_multiplier_when_nonzero() {
     configure_dst_config(&setup, 43, DstConfig { gas: 1, multiplier_bps: 9_000, floor_margin_usd: 0 });
 
     let fee = with_contract(&setup, || {
-        Dvn::get_fee(
+        LzDVN::get_fee(
             &setup.env,
             &new_addr(&setup.env),
             &new_addr(&setup.env),
@@ -145,54 +144,54 @@ fn test_pause_and_setters_happy_paths() {
     let other = new_addr(&setup.env);
 
     with_contract(&setup, || {
-        Dvn::set_paused(&setup.env, true);
+        LzDVN::set_paused(&setup.env, true);
     });
     with_contract(&setup, || {
-        assert!(Dvn::paused(&setup.env));
+        assert!(LzDVN::paused(&setup.env));
     });
     with_contract(&setup, || {
-        Dvn::set_paused(&setup.env, false);
+        LzDVN::set_paused(&setup.env, false);
     });
     with_contract(&setup, || {
-        assert!(!Dvn::paused(&setup.env));
+        assert!(!LzDVN::paused(&setup.env));
     });
 
     with_contract(&setup, || {
-        Dvn::set_default_multiplier_bps(&setup.env, &admin, 1234);
+        LzDVN::set_default_multiplier_bps(&setup.env, &admin, 1234);
     });
     with_contract(&setup, || {
-        assert_eq!(Dvn::default_multiplier_bps(&setup.env), 1234);
+        assert_eq!(LzDVN::default_multiplier_bps(&setup.env), 1234);
     });
 
     with_contract(&setup, || {
-        Dvn::set_deposit_address(&setup.env, &admin, &other);
+        LzDVN::set_deposit_address(&setup.env, &admin, &other);
     });
     with_contract(&setup, || {
-        assert_eq!(Dvn::deposit_address(&setup.env), other);
+        assert_eq!(LzDVN::deposit_address(&setup.env), other);
     });
 
     let pf = new_addr(&setup.env);
     with_contract(&setup, || {
-        Dvn::set_price_feed(&setup.env, &admin, &pf);
+        LzDVN::set_price_feed(&setup.env, &admin, &pf);
     });
     with_contract(&setup, || {
-        assert_eq!(Dvn::price_feed(&setup.env), pf);
+        assert_eq!(LzDVN::price_feed(&setup.env), pf);
     });
 
     let opts = Bytes::from_array(&setup.env, &[1, 2, 3]);
     with_contract(&setup, || {
-        Dvn::set_supported_option_types(&setup.env, &admin, 77, opts.clone());
+        LzDVN::set_supported_option_types(&setup.env, &admin, 77, opts.clone());
     });
     with_contract(&setup, || {
-        assert_eq!(Dvn::get_supported_option_types(&setup.env, 77), Some(opts));
+        assert_eq!(LzDVN::get_supported_option_types(&setup.env, 77), Some(opts));
     });
 
     let fee_lib = new_addr(&setup.env);
     with_contract(&setup, || {
-        Dvn::set_worker_fee_lib(&setup.env, &admin, &fee_lib);
+        LzDVN::set_worker_fee_lib(&setup.env, &admin, &fee_lib);
     });
     with_contract(&setup, || {
-        assert_eq!(Dvn::worker_fee_lib(&setup.env), fee_lib);
+        assert_eq!(LzDVN::worker_fee_lib(&setup.env), fee_lib);
     });
 }
 
@@ -201,9 +200,9 @@ fn test_acl_and_allowlist_size_reads() {
     let setup = TestSetup::new(1);
     let addr = setup.admins.get(0).unwrap();
 
-    let has_acl = with_contract(&setup, || Dvn::has_acl(&setup.env, &addr));
+    let has_acl = with_contract(&setup, || LzDVN::has_acl(&setup.env, &addr));
     assert!(has_acl);
-    let allowlist_size = with_contract(&setup, || Dvn::allowlist_size(&setup.env));
+    let allowlist_size = with_contract(&setup, || LzDVN::allowlist_size(&setup.env));
     assert_eq!(allowlist_size, 0);
 }
 
@@ -251,14 +250,14 @@ fn test_assign_job_auth_verification() {
     configure_dst_config(&setup, dst_eid, DstConfig { gas: 1, multiplier_bps: 10_000, floor_margin_usd: 0 });
 
     with_contract(&setup, || {
-        Dvn::set_deposit_address(&setup.env, &admin, &deposit_addr);
+        LzDVN::set_deposit_address(&setup.env, &admin, &deposit_addr);
     });
     with_contract(&setup, || {
-        Dvn::set_supported_message_lib(&setup.env, &send_lib, true);
+        LzDVN::set_supported_message_lib(&setup.env, &send_lib, true);
     });
 
     let result = setup.env.as_contract(&setup.contract_id, || {
-        Dvn::assign_job(&setup.env, &send_lib, &sender, dst_eid, &packet_header, &payload_hash, 1, &options)
+        LzDVN::assign_job(&setup.env, &send_lib, &sender, dst_eid, &packet_header, &payload_hash, 1, &options)
     });
 
     assert_eq!(result, FeeRecipient { amount: 10_000, to: deposit_addr.clone() });
@@ -275,16 +274,16 @@ fn test_set_admin_add() {
     let new_admin = new_addr(&setup.env);
 
     // Verify new_admin is not an admin initially
-    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    let is_admin = with_contract(&setup, || LzDVN::is_admin(&setup.env, &new_admin));
     assert!(!is_admin);
 
     // Add new admin by existing admin
     with_contract(&setup, || {
-        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, true);
+        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, true);
     });
 
     // Verify new_admin is now an admin
-    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    let is_admin = with_contract(&setup, || LzDVN::is_admin(&setup.env, &new_admin));
     assert!(is_admin);
 }
 
@@ -296,16 +295,16 @@ fn test_set_admin_remove() {
 
     // Add new admin first
     with_contract(&setup, || {
-        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, true);
+        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, true);
     });
 
     // Remove the new admin
     with_contract(&setup, || {
-        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, false);
+        LzDVN::set_admin(&setup.env, &existing_admin, &new_admin, false);
     });
 
     // Verify new_admin is no longer an admin
-    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    let is_admin = with_contract(&setup, || LzDVN::is_admin(&setup.env, &new_admin));
     assert!(!is_admin);
 }
 
@@ -318,7 +317,7 @@ fn test_set_admin_unauthorized() {
 
     // Attempt to add admin by non-admin should fail
     with_contract(&setup, || {
-        Dvn::set_admin(&setup.env, &non_admin, &new_admin, true);
+        LzDVN::set_admin(&setup.env, &non_admin, &new_admin, true);
     });
 }
 
@@ -330,7 +329,7 @@ fn test_set_admin_cannot_remove_last_admin() {
 
     // Attempt to remove the only admin should fail
     with_contract(&setup, || {
-        Dvn::set_admin(&setup.env, &existing_admin, &existing_admin, false);
+        LzDVN::set_admin(&setup.env, &existing_admin, &existing_admin, false);
     });
 }
 
@@ -339,7 +338,7 @@ struct MockFeeLib;
 
 #[contractimpl]
 impl IDvnFeeLib for MockFeeLib {
-    fn get_fee(_env: &Env, params: &DvnFeeParams) -> i128 {
+    fn get_fee(_env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
         if params.multiplier_bps == 0 {
             params.default_multiplier_bps as i128
         } else {

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

@@ -1,5 +1,5 @@
-use crate::errors::MultisigError;
-use crate::storage::MultisigStorage;
+use crate::errors::DvnError;
+use crate::storage::DvnStorage;
 use crate::tests::setup::TestSetup;
 use soroban_sdk::{
     testutils::{AuthorizedFunction, BytesN as _},
@@ -12,7 +12,7 @@ fn random_signer(env: &Env) -> BytesN<20> {
 
 fn clear_signers(setup: &TestSetup) {
     setup.env.as_contract(&setup.contract_id, || {
-        MultisigStorage::remove_signers(&setup.env);
+        DvnStorage::remove_signers(&setup.env);
     });
 }
 
@@ -48,7 +48,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(), MultisigError::SignerAlreadyExists.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerAlreadyExists.into());
 }
 
 #[test]
@@ -69,7 +69,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(), MultisigError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerNotFound.into());
 }
 
 #[test]
@@ -78,7 +78,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(), MultisigError::InvalidSigner.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::InvalidSigner.into());
 }
 
 #[test]
@@ -115,7 +115,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(), MultisigError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::SignerNotFound.into());
 }
 
 #[test]
@@ -129,5 +129,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(), MultisigError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
 }

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

@@ -1,5 +1,5 @@
 use crate::tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID};
-use crate::{dvn::Dvn, errors::MultisigError, storage::MultisigStorage};
+use crate::{dvn::LzDVN, errors::DvnError, storage::DvnStorage};
 use soroban_sdk::{
     testutils::{Address as _, AuthorizedFunction, BytesN as _},
     vec, Address, BytesN, Env, IntoVal, Symbol, Vec,
@@ -21,7 +21,7 @@ fn register_dvn(env: &Env, signer_count: usize, threshold: u32) {
     let deposit_address: Address = Address::generate(env);
 
     let _ = env.register(
-        Dvn,
+        LzDVN,
         (
             &VID,
             &signers,
@@ -29,8 +29,8 @@ fn register_dvn(env: &Env, signer_count: usize, threshold: u32) {
             &admins,
             &supported_msglibs,
             &price_feed,
-            &worker_fee_lib,
             &DEFAULT_MULTIPLIER_BPS,
+            &worker_fee_lib,
             &deposit_address,
         ),
     );
@@ -66,7 +66,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(), MultisigError::ZeroThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::ZeroThreshold.into());
 }
 
 #[test]
@@ -74,7 +74,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(), MultisigError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
@@ -82,15 +82,15 @@ fn test_set_threshold_with_no_signers_fails() {
     let setup = TestSetup::new(1);
 
     setup.env.as_contract(&setup.contract_id, || {
-        MultisigStorage::remove_signers(&setup.env);
+        DvnStorage::remove_signers(&setup.env);
     });
 
     let res = setup.multisig_client.try_set_threshold(&1);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1)")] // MultisigError::ZeroThreshold
+#[should_panic(expected = "Error(Contract, #13)")] // DvnError::ZeroThreshold
 fn test_constructor_threshold_zero_panics() {
     let env = Env::default();
     env.mock_all_auths();
@@ -99,7 +99,7 @@ fn test_constructor_threshold_zero_panics() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2)")] // MultisigError::TotalSignersLessThanThreshold
+#[should_panic(expected = "Error(Contract, #11)")] // DvnError::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,6 +1,6 @@
 extern crate std;
 
-use crate::storage::MultisigStorage;
+use crate::storage::DvnStorage;
 use crate::tests::key_pair::KeyPair;
 use crate::tests::setup::TestSetup;
 use soroban_sdk::{vec, Bytes, BytesN, Vec};
@@ -59,7 +59,7 @@ fn test_verify_signatures_raw_v_path() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #5)")] // MultisigError::SignerNotFound
+#[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");
@@ -71,7 +71,7 @@ fn test_verify_signatures_with_wrong_signer() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #7)")] // MultisigError::SignatureError
+#[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");
@@ -82,7 +82,7 @@ fn test_verify_signatures_insufficient_signatures() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #6)")] // MultisigError::UnsortedSigners
+#[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");
@@ -94,12 +94,12 @@ fn test_verify_signatures_duplicate_signer() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1)")] // MultisigError::ZeroThreshold
+#[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, || {
-        MultisigStorage::set_threshold(&setup.env, &0);
+        DvnStorage::set_threshold(&setup.env, &0);
     });
     let digest = hash(&setup.env, b"threshold_zero");
 

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

@@ -3,7 +3,7 @@
 extern crate std;
 
 use crate::tests::key_pair::KeyPair;
-use crate::{dvn::Dvn, interfaces::MultiSigClient};
+use crate::{dvn::LzDVN, interfaces::MultiSigClient};
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
 use std::vec::Vec as StdVec;
 
@@ -44,7 +44,7 @@ impl<'a> TestSetup<'a> {
         let deposit_address: Address = Address::generate(&env);
 
         let contract_id = env.register(
-            Dvn,
+            LzDVN,
             (
                 &VID,
                 &signers,
@@ -52,8 +52,8 @@ impl<'a> TestSetup<'a> {
                 &admins,
                 &supported_msglibs,
                 &price_feed,
-                &worker_fee_lib,
                 &DEFAULT_MULTIPLIER_BPS,
+                &worker_fee_lib,
                 &deposit_address,
             ),
         );
@@ -88,7 +88,7 @@ impl<'a> TestSetup<'a> {
         let deposit_address: Address = Address::generate(&env);
 
         let contract_id = env.register(
-            Dvn,
+            LzDVN,
             (
                 &VID,
                 &signers,
@@ -96,8 +96,8 @@ impl<'a> TestSetup<'a> {
                 &admins,
                 &supported_msglibs,
                 &price_feed,
-                &worker_fee_lib,
                 &DEFAULT_MULTIPLIER_BPS,
+                &worker_fee_lib,
                 &deposit_address,
             ),
         );

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

@@ -16,9 +16,10 @@ doctest = false
 [dependencies]
 cfg-if = "1.0"
 soroban-sdk = { workspace = true }
+common-macros = { workspace = true }
 message-lib-common = { workspace = true }
+utils = { 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

@@ -1,5 +1,6 @@
 use crate::DvnFeeLibError;
-use soroban_sdk::{assert_with_error, contract, contractimpl, Env};
+use common_macros::contract_impl;
+use soroban_sdk::{assert_with_error, contract, Address, Env};
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
@@ -29,9 +30,9 @@ pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 #[contract]
 pub struct DvnFeeLib;
 
-#[contractimpl]
+#[contract_impl]
 impl IDvnFeeLib for DvnFeeLib {
-    fn get_fee(env: &Env, params: &DvnFeeParams) -> i128 {
+    fn get_fee(env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
         assert_with_error!(env, params.gas > 0, DvnFeeLibError::InvalidGas);
         assert_with_error!(env, params.options.is_empty(), DvnFeeLibError::InvalidDVNOptions);
 

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

@@ -77,6 +77,7 @@ fn apply_premium_multiplier_wins_over_small_floor() {
 fn get_fee_panics_when_gas_zero() {
     let env = Env::default();
     env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
     let params = DvnFeeParams {
         sender: Address::generate(&env),
         dst_eid: 1,
@@ -90,7 +91,7 @@ fn get_fee_panics_when_gas_zero() {
         floor_margin_usd: 0,
     };
 
-    DvnFeeLib::get_fee(&env, &params);
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[test]
@@ -98,6 +99,7 @@ fn get_fee_panics_when_gas_zero() {
 fn get_fee_panics_when_options_not_empty() {
     let env = Env::default();
     env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
     let mut options = Bytes::new(&env);
     options.push_back(1u8);
 
@@ -114,7 +116,7 @@ fn get_fee_panics_when_options_not_empty() {
         floor_margin_usd: 0,
     };
 
-    DvnFeeLib::get_fee(&env, &params);
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[contract]
@@ -183,7 +185,7 @@ fn get_fee_success_path() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 100);
 }
@@ -209,7 +211,7 @@ fn get_fee_uses_default_multiplier_when_zero() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 120);
 }
@@ -235,7 +237,7 @@ fn get_fee_prefers_dst_multiplier_over_default() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 150);
 }
@@ -259,7 +261,7 @@ fn get_fee_panics_when_price_feed_returns_negative_fee() {
         floor_margin_usd: 0,
     };
 
-    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[test]

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

@@ -0,0 +1,93 @@
+use super::*;
+
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    auth::{Context, CustomAccountInterface},
+    contractimpl, contracttype,
+    crypto::Hash,
+};
+
+// ============================================================================
+// Authentication Data Types
+// ============================================================================
+
+/// Signature data for Custom Account authorization.
+/// Contains the admin's public key and their Ed25519 signature over the authorization payload.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ExecutorSignature {
+    /// Admin's Ed25519 public key (32 bytes) - must correspond to a registered admin
+    pub public_key: BytesN<32>,
+    /// Ed25519 signature (64 bytes) over the signature_payload
+    pub signature: BytesN<64>,
+}
+
+// ============================================================================
+// Custom Account Interface Implementation
+// ============================================================================
+
+#[contractimpl]
+impl CustomAccountInterface for LzExecutor {
+    type Signature = ExecutorSignature;
+    type Error = ExecutorError;
+
+    /// Verifies authorization for the executor contract.
+    ///
+    /// The public key must correspond to a registered admin and must have signed the signature_payload.
+    /// Uses Ed25519 signature verification.
+    /// Only whitelisted function calls are authorized.
+    fn __check_auth(
+        env: Env,
+        signature_payload: Hash<32>,
+        auth_data: Self::Signature,
+        auth_contexts: Vec<Context>,
+    ) -> Result<(), Self::Error> {
+        Self::verify_admin_signature(&env, &signature_payload, &auth_data)?;
+        Self::validate_auth_contexts(&env, &auth_contexts)?;
+        Ok(())
+    }
+}
+
+// ============================================================================
+// Internal Helper Functions
+// ============================================================================
+
+impl LzExecutor {
+    /// Verifies that the signature is from a registered admin.
+    ///
+    /// Converts the public key to an address, checks admin registration,
+    /// and verifies the Ed25519 signature over the payload.
+    fn verify_admin_signature(
+        env: &Env,
+        signature_payload: &Hash<32>,
+        auth_data: &ExecutorSignature,
+    ) -> Result<(), ExecutorError> {
+        let admin = Address::from_payload(env, AddressPayload::AccountIdPublicKeyEd25519(auth_data.public_key.clone()));
+        if !Self::is_admin(env, &admin) {
+            return Err(ExecutorError::Unauthorized);
+        }
+        env.crypto().ed25519_verify(&auth_data.public_key, &signature_payload.clone().into(), &auth_data.signature);
+        Ok(())
+    }
+
+    /// Validates that the first auth context is a whitelisted (contract, function) pair.
+    /// Sub-invocations are trusted since they're controlled by the whitelisted contract.
+    fn validate_auth_contexts(env: &Env, contexts: &Vec<Context>) -> Result<(), ExecutorError> {
+        let first_context = contexts.first().ok_or(ExecutorError::UnauthorizedContext)?;
+
+        match first_context {
+            Context::Contract(contract_context) => {
+                // Check if (contract, fn_name) pair is whitelisted
+                if !Self::is_whitelisted_fn(env, &contract_context.contract, &contract_context.fn_name) {
+                    return Err(ExecutorError::UnauthorizedContext);
+                }
+            }
+            // Contract creation is not allowed
+            Context::CreateContractHostFn(_) | Context::CreateContractWithCtorHostFn(_) => {
+                return Err(ExecutorError::UnauthorizedContext);
+            }
+        }
+
+        Ok(())
+    }
+}