@layerzerolabs/protocol-stellar-v2 0.2.11 → 0.2.13

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

@@ -1,5 +1,8 @@
 use crate::tests::setup::{TestSetup, VID};
-use crate::{dvn::auth::TransactionAuthData, errors::DvnError, errors::MultisigError};
+use crate::{
+    dvn::auth::{Sender, TransactionAuthData},
+    errors::DvnError,
+};
 use ed25519_dalek::{Signer, SigningKey};
 use rand::thread_rng;
 use soroban_sdk::{auth::Context, vec, Bytes, BytesN, Env, IntoVal, Vec};
@@ -49,13 +52,18 @@ fn test_check_auth_success() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = admin_kp.public_key(&env);
-    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -78,13 +86,18 @@ fn test_check_auth_not_admin() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = non_admin_kp.public_key(&env);
-    let admin_signature = non_admin_kp.sign(&env, &payload.to_array());
+    let public_key = non_admin_kp.public_key(&env);
+    let signature = non_admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -108,24 +121,28 @@ fn test_check_auth_wrong_signer_fails() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = admin_kp.public_key(&env);
-    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
     let wrong_sig = crate::tests::key_pair::KeyPair::generate().sign_bytes(&env, &hash);
 
-    let tx_auth =
-        TransactionAuthData { vid: VID, expiration, signatures: vec![&env, wrong_sig], admin, admin_signature };
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, wrong_sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
-    // verify_signatures panics with MultisigError::SignerNotFound when signer is not found
-    let res = env.try_invoke_contract_check_auth::<MultisigError>(
+    // verify_signatures panics with DvnError::SignerNotFound when signer is not found
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
         &payload,
         tx_auth.into_val(&env),
         &auth_contexts,
     );
 
-    assert_eq!(res, Err(Ok(MultisigError::SignerNotFound)));
+    assert_eq!(res, Err(Ok(DvnError::SignerNotFound)));
 }
 
 #[test]
@@ -141,14 +158,18 @@ fn test_check_auth_invalid_vid_fails() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = admin_kp.public_key(&env);
-    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, wrong_vid, expiration, &auth_contexts);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth =
-        TransactionAuthData { vid: wrong_vid, expiration, signatures: vec![&env, sig], admin, admin_signature };
+    let tx_auth = TransactionAuthData {
+        vid: wrong_vid,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -172,13 +193,18 @@ fn test_check_auth_expired_fails() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = admin_kp.public_key(&env);
-    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
 
-    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,
@@ -202,8 +228,8 @@ fn test_check_auth_hash_already_used_fails() {
     let auth_contexts: Vec<Context> = Vec::new(&env);
 
     let payload = BytesN::from_array(&env, &[0u8; 32]);
-    let admin = admin_kp.public_key(&env);
-    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+    let public_key = admin_kp.public_key(&env);
+    let signature = admin_kp.sign(&env, &payload.to_array());
 
     let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
     let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
@@ -212,8 +238,7 @@ fn test_check_auth_hash_already_used_fails() {
         vid: VID,
         expiration,
         signatures: vec![&env, sig.clone()],
-        admin: admin.clone(),
-        admin_signature: admin_signature.clone(),
+        sender: Sender::Admin(public_key.clone(), signature.clone()),
     };
 
     let res = env.try_invoke_contract_check_auth::<DvnError>(
@@ -224,7 +249,12 @@ fn test_check_auth_hash_already_used_fails() {
     );
     assert!(res.is_ok());
 
-    let tx_auth2 = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+    let tx_auth2 = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig],
+        sender: Sender::Admin(public_key, signature),
+    };
 
     let res2 = env.try_invoke_contract_check_auth::<DvnError>(
         &setup.contract_id,

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);
     });
 }
 
@@ -59,7 +59,7 @@ fn test_dst_config_not_set_returns_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);
@@ -69,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);
     });
 }
 
@@ -87,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);
     });
 }
 
@@ -99,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),
@@ -122,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),
@@ -144,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);
     });
 }
 
@@ -200,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);
 }
 
@@ -250,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() });
@@ -274,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);
 }
 
@@ -295,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);
 }
 
@@ -317,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);
     });
 }
 
@@ -329,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);
     });
 }
 

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,
             ),
         );