@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

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

@@ -1,5 +1,6 @@
 use super::setup::{bare_worker, TestSetup, WorkerTester};
 use crate::{
+    errors::WorkerError,
     events::{
         Paused, SetAdmin, SetAllowlist, SetDefaultMultiplierBps, SetDenylist, SetDepositAddress, SetPriceFeed,
         SetSupportedMessageLib, SetSupportedOptionTypes, SetWorkerFeeLib, Unpaused,
@@ -7,17 +8,16 @@ use crate::{
     init_worker,
 };
 use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, Env, IntoVal};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 // pause
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::PauseStatusUnchanged
 fn test_set_paused_rejects_unchanged_status() {
     let setup = TestSetup::new();
 
     setup.mock_owner_auth("set_paused", (false,));
-    setup.client.set_paused(&false);
+    assert_eq!(setup.client.try_set_paused(&false).unwrap_err().unwrap(), WorkerError::PauseStatusUnchanged.into());
 }
 
 #[test]
@@ -26,19 +26,18 @@ fn test_set_paused_toggles_state() {
 
     setup.mock_owner_auth("set_paused", (true,));
     setup.client.set_paused(&true);
-    assert_event(&setup.env, &setup.contract_id, Paused { pauser: setup.owner.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, Paused { pauser: setup.owner.clone() });
     assert_eq!(setup.client.paused(), true);
 
     setup.mock_owner_auth("set_paused", (false,));
     setup.client.set_paused(&false);
-    assert_event(&setup.env, &setup.contract_id, Unpaused { unpauser: setup.owner.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, Unpaused { unpauser: setup.owner.clone() });
     assert_eq!(setup.client.paused(), false);
 }
 
 // allowlist
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1202)")] // WorkerError::AlreadyOnAllowlist
 fn test_allowlist_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -47,17 +46,19 @@ fn test_allowlist_rejects_duplicate_add() {
     setup.client.set_allowlist(&oapp, &true);
 
     setup.mock_owner_auth("set_allowlist", (&oapp, true));
-    setup.client.set_allowlist(&oapp, &true);
+    assert_eq!(
+        setup.client.try_set_allowlist(&oapp, &true).unwrap_err().unwrap(),
+        WorkerError::AlreadyOnAllowlist.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1210)")] // WorkerError::NotOnAllowlist
 fn test_allowlist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_allowlist", (&oapp, false));
-    setup.client.set_allowlist(&oapp, &false);
+    assert_eq!(setup.client.try_set_allowlist(&oapp, &false).unwrap_err().unwrap(), WorkerError::NotOnAllowlist.into());
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), false);
     setup.mock_owner_auth("set_allowlist", (&oapp_a, true));
     setup.client.set_allowlist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: true });
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), true);
     assert_eq!(setup.client.allowlist_size(), 1);
     assert_eq!(setup.client.has_acl(&oapp_a), true);
@@ -79,7 +80,7 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
     // Remove last allowlist entry => allowlist empty; default allows all (unless denylisted)
     setup.mock_owner_auth("set_allowlist", (&oapp_a, false));
     setup.client.set_allowlist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: false });
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), false);
     assert_eq!(setup.client.allowlist_size(), 0);
     assert_eq!(setup.client.has_acl(&oapp_b), true);
@@ -88,7 +89,6 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
 // denylist
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1203)")] // WorkerError::AlreadyOnDenylist
 fn test_denylist_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -97,17 +97,19 @@ fn test_denylist_rejects_duplicate_add() {
     setup.client.set_denylist(&oapp, &true);
 
     setup.mock_owner_auth("set_denylist", (&oapp, true));
-    setup.client.set_denylist(&oapp, &true);
+    assert_eq!(
+        setup.client.try_set_denylist(&oapp, &true).unwrap_err().unwrap(),
+        WorkerError::AlreadyOnDenylist.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1211)")] // WorkerError::NotOnDenylist
 fn test_denylist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_denylist", (&oapp, false));
-    setup.client.set_denylist(&oapp, &false);
+    assert_eq!(setup.client.try_set_denylist(&oapp, &false).unwrap_err().unwrap(), WorkerError::NotOnDenylist.into());
 }
 
 // message_libs
@@ -122,7 +124,7 @@ fn test_message_lib_add_remove_and_errors() {
     // Add new supported lib
     setup.mock_owner_auth("set_supported_message_lib", (&new_lib, true));
     setup.client.set_supported_message_lib(&new_lib, &true);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedMessageLib { message_lib: new_lib.clone(), supported: true },
@@ -132,7 +134,7 @@ fn test_message_lib_add_remove_and_errors() {
     // Remove it
     setup.mock_owner_auth("set_supported_message_lib", (&new_lib, false));
     setup.client.set_supported_message_lib(&new_lib, &false);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedMessageLib { message_lib: new_lib.clone(), supported: false },
@@ -144,29 +146,32 @@ fn test_message_lib_add_remove_and_errors() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1206)")] // WorkerError::MessageLibAlreadySupported
 fn test_message_lib_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let existing = setup.message_libs.get(0).unwrap();
 
     setup.mock_owner_auth("set_supported_message_lib", (&existing, true));
-    setup.client.set_supported_message_lib(&existing, &true);
+    assert_eq!(
+        setup.client.try_set_supported_message_lib(&existing, &true).unwrap_err().unwrap(),
+        WorkerError::MessageLibAlreadySupported.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1207)")] // WorkerError::MessageLibNotSupported
 fn test_message_lib_rejects_remove_missing() {
     let setup = TestSetup::new();
     let missing = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_supported_message_lib", (&missing, false));
-    setup.client.set_supported_message_lib(&missing, &false);
+    assert_eq!(
+        setup.client.try_set_supported_message_lib(&missing, &false).unwrap_err().unwrap(),
+        WorkerError::MessageLibNotSupported.into()
+    );
 }
 
 // admin-only setters
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
 fn test_admin_only_set_default_multiplier_requires_admin_membership() {
     let setup = TestSetup::new();
 
@@ -175,7 +180,10 @@ fn test_admin_only_set_default_multiplier_requires_admin_membership() {
 
     // Auth passes, but address isn't in admins list => Unauthorized
     setup.mock_auth(&non_admin, "set_default_multiplier_bps", (&non_admin, bps));
-    setup.client.set_default_multiplier_bps(&non_admin, &bps);
+    assert_eq!(
+        setup.client.try_set_default_multiplier_bps(&non_admin, &bps).unwrap_err().unwrap(),
+        WorkerError::Unauthorized.into()
+    );
 }
 
 #[test]
@@ -187,15 +195,15 @@ fn test_admin_setters_update_storage_and_events() {
     let bps = 12_000u32;
     setup.mock_auth(&admin, "set_default_multiplier_bps", (&admin, bps));
     setup.client.set_default_multiplier_bps(&admin, &bps);
-    assert_event(&setup.env, &setup.contract_id, SetDefaultMultiplierBps { multiplier_bps: bps });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDefaultMultiplierBps { multiplier_bps: bps });
     assert_eq!(setup.client.default_multiplier_bps(), bps);
 
     // set_deposit_address
     let new_deposit = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_deposit_address", (&admin, &new_deposit));
     setup.client.set_deposit_address(&admin, &new_deposit);
-    assert_event(&setup.env, &setup.contract_id, SetDepositAddress { deposit_address: new_deposit.clone() });
-    assert_eq!(setup.client.deposit_address(), new_deposit);
+    assert_eq_event(&setup.env, &setup.contract_id, SetDepositAddress { deposit_address: new_deposit.clone() });
+    assert_eq!(setup.client.deposit_address(), Some(new_deposit));
 
     // set_supported_option_types
     let eid_a = 1u32;
@@ -204,7 +212,7 @@ fn test_admin_setters_update_storage_and_events() {
     let option_types = Bytes::from_slice(&setup.env, &[0xAA, 0xBB, 0xCC]);
     setup.mock_auth(&admin, "set_supported_option_types", (&admin, eid_a, option_types.clone()));
     setup.client.set_supported_option_types(&admin, &eid_a, &option_types);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedOptionTypes { dst_eid: eid_a, option_types: option_types.clone() },
@@ -217,15 +225,15 @@ fn test_admin_setters_update_storage_and_events() {
     let new_fee_lib = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_worker_fee_lib", (&admin, &new_fee_lib));
     setup.client.set_worker_fee_lib(&admin, &new_fee_lib);
-    assert_event(&setup.env, &setup.contract_id, SetWorkerFeeLib { fee_lib: new_fee_lib.clone() });
-    assert_eq!(setup.client.worker_fee_lib(), new_fee_lib);
+    assert_eq_event(&setup.env, &setup.contract_id, SetWorkerFeeLib { fee_lib: new_fee_lib.clone() });
+    assert_eq!(setup.client.worker_fee_lib(), Some(new_fee_lib));
 
     // set_price_feed
     let new_price_feed = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_price_feed", (&admin, &new_price_feed));
     setup.client.set_price_feed(&admin, &new_price_feed);
-    assert_event(&setup.env, &setup.contract_id, SetPriceFeed { price_feed: new_price_feed.clone() });
-    assert_eq!(setup.client.price_feed(), new_price_feed);
+    assert_eq_event(&setup.env, &setup.contract_id, SetPriceFeed { price_feed: new_price_feed.clone() });
+    assert_eq!(setup.client.price_feed(), Some(new_price_feed));
 }
 
 // view functions
@@ -243,14 +251,14 @@ fn test_acl_allowlist_denylist_precedence() {
     assert_eq!(setup.client.is_on_denylist(&oapp_a), false);
     setup.mock_owner_auth("set_denylist", (&oapp_a, true));
     setup.client.set_denylist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
     assert_eq!(setup.client.is_on_denylist(&oapp_a), true);
     assert_eq!(setup.client.has_acl(&oapp_a), false);
 
     // Remove from denylist => allowed again (since allowlist is empty)
     setup.mock_owner_auth("set_denylist", (&oapp_a, false));
     setup.client.set_denylist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
     assert_eq!(setup.client.is_on_denylist(&oapp_a), false);
     assert_eq!(setup.client.has_acl(&oapp_a), true);
 
@@ -264,43 +272,40 @@ fn test_acl_allowlist_denylist_precedence() {
     // Denylist must override allowlist even for the same OApp.
     setup.mock_owner_auth("set_denylist", (&oapp_a, true));
     setup.client.set_denylist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
     assert_eq!(setup.client.has_acl(&oapp_a), false);
 
     // Removing from denylist should restore allowlist effect.
     setup.mock_owner_auth("set_denylist", (&oapp_a, false));
     setup.client.set_denylist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
     assert_eq!(setup.client.has_acl(&oapp_a), true);
 }
 
 // uninitialized getters (BareWorker)
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1205)")] // WorkerError::DepositAddressNotSet
 fn test_view_panics_when_deposit_address_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.deposit_address();
+    assert_eq!(client.deposit_address(), None);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1213)")] // WorkerError::PriceFeedNotSet
 fn test_view_panics_when_price_feed_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.price_feed();
+    assert_eq!(client.price_feed(), None);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1217)")] // WorkerError::WorkerFeeLibNotSet
 fn test_view_panics_when_worker_fee_lib_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.worker_fee_lib();
+    assert_eq!(client.worker_fee_lib(), None);
 }
 
 #[test]
@@ -314,8 +319,7 @@ fn test_default_multiplier_bps_returns_zero_when_unset() {
 // init_worker / construction
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1208)")] // WorkerError::NoAdminsProvided
-fn test_init_worker_requires_non_empty_admins() {
+fn test_init_worker_allows_empty_admins() {
     let env = Env::default();
 
     let owner = Address::generate(&env);
@@ -326,29 +330,39 @@ fn test_init_worker_requires_non_empty_admins() {
     let deposit_address = Address::generate(&env);
     let default_multiplier_bps = 10_000u32;
 
-    // Panics inside __constructor via init_worker()
-    let _ = env.register(
+    // Empty admins is now allowed
+    let cid = env.register(
         WorkerTester,
         (&owner, &admins, &message_libs, &price_feed, &default_multiplier_bps, &worker_fee_lib, &deposit_address),
     );
+    let client = super::setup::WorkerTesterClient::new(&env, &cid);
+    assert_eq!(client.admins().len(), 0);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1214)")] // WorkerError::ReInitialize
-fn test_init_worker_cannot_reinitialize() {
+fn test_init_worker_can_reinitialize() {
     let setup = TestSetup::new();
+    let new_admin = Address::generate(&setup.env);
+    let new_admins = vec![&setup.env, new_admin.clone()];
+    let new_message_lib = Address::generate(&setup.env);
+    let new_message_libs = vec![&setup.env, new_message_lib.clone()];
 
+    // Re-initialization is allowed - adds new admins and message libs
     setup.as_contract(|| {
         init_worker::<WorkerTester>(
             &setup.env,
-            &setup.admins,
-            &setup.message_libs,
+            &new_admins,
+            &new_message_libs, // Use new message libs to avoid duplicate error
             &setup.price_feed,
             setup.default_multiplier_bps,
             &setup.worker_fee_lib,
             &setup.deposit_address,
         );
     });
+
+    // Verify new admin and message lib were added
+    assert!(setup.client.is_admin(&new_admin));
+    assert!(setup.client.is_supported_message_lib(&new_message_lib));
 }
 
 #[test]
@@ -358,9 +372,9 @@ fn test_init_worker_sets_config_and_defaults() {
     assert_eq!(setup.client.paused(), false);
     assert_eq!(setup.client.admins(), setup.admins);
     assert_eq!(setup.client.message_libs(), setup.message_libs);
-    assert_eq!(setup.client.price_feed(), setup.price_feed);
-    assert_eq!(setup.client.worker_fee_lib(), setup.worker_fee_lib);
-    assert_eq!(setup.client.deposit_address(), setup.deposit_address);
+    assert_eq!(setup.client.price_feed(), Some(setup.price_feed));
+    assert_eq!(setup.client.worker_fee_lib(), Some(setup.worker_fee_lib));
+    assert_eq!(setup.client.deposit_address(), Some(setup.deposit_address));
     assert_eq!(setup.client.default_multiplier_bps(), setup.default_multiplier_bps);
     assert_eq!(setup.client.allowlist_size(), 0);
 
@@ -375,40 +389,43 @@ fn test_admin_management_by_owner_adds_and_removes_admin() {
     let setup = TestSetup::new();
     let new_admin = Address::generate(&setup.env);
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&new_admin, true));
-    setup.client.set_admin_by_owner_for_test(&new_admin, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
+    setup.mock_owner_auth("set_admin", (&new_admin, true));
+    setup.client.set_admin(&new_admin, &true);
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
     assert_eq!(setup.client.is_admin(&new_admin), true);
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&new_admin, false));
-    setup.client.set_admin_by_owner_for_test(&new_admin, &false);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: false });
+    setup.mock_owner_auth("set_admin", (&new_admin, false));
+    setup.client.set_admin(&new_admin, &false);
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: false });
     assert_eq!(setup.client.is_admin(&new_admin), false);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")] // WorkerError::AdminAlreadyExists
 fn test_admin_management_by_owner_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let existing_admin = setup.admins.get(0).unwrap();
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&existing_admin, true));
-    setup.client.set_admin_by_owner_for_test(&existing_admin, &true);
+    setup.mock_owner_auth("set_admin", (&existing_admin, true));
+    assert_eq!(
+        setup.client.try_set_admin(&existing_admin, &true).unwrap_err().unwrap(),
+        WorkerError::AdminAlreadyExists.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1201)")] // WorkerError::AdminNotFound
 fn test_admin_management_by_owner_rejects_remove_missing_admin() {
     let setup = TestSetup::new();
     let missing_admin = Address::generate(&setup.env);
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&missing_admin, false));
-    setup.client.set_admin_by_owner_for_test(&missing_admin, &false);
+    setup.mock_owner_auth("set_admin", (&missing_admin, false));
+    assert_eq!(
+        setup.client.try_set_admin(&missing_admin, &false).unwrap_err().unwrap(),
+        WorkerError::AdminNotFound.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1204)")] // WorkerError::AttemptingToRemoveOnlyAdmin
-fn test_admin_management_cannot_remove_last_admin() {
+fn test_admin_management_can_remove_last_admin() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let admins: soroban_sdk::Vec<Address> = vec![&env, Address::generate(&env)];
@@ -429,13 +446,16 @@ fn test_admin_management_cannot_remove_last_admin() {
         address: &owner,
         invoke: &soroban_sdk::testutils::MockAuthInvoke {
             contract: &cid,
-            fn_name: "set_admin_by_owner_for_test",
+            fn_name: "set_admin",
             args: (&only_admin, false).into_val(&env),
             sub_invokes: &[],
         },
     }]);
 
-    client.set_admin_by_owner_for_test(&only_admin, &false);
+    // Removing the last admin is now allowed
+    client.set_admin(&only_admin, &false);
+    assert_eq!(client.is_admin(&only_admin), false);
+    assert_eq!(client.admins().len(), 0);
 }
 
 #[test]
@@ -446,23 +466,25 @@ fn test_admin_management_by_admin_can_add_admin() {
 
     setup.mock_auth(&caller, "set_admin_by_admin_for_test", (&caller, &new_admin, true));
     setup.client.set_admin_by_admin_for_test(&caller, &new_admin, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
     assert_eq!(setup.client.is_admin(&new_admin), true);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
 fn test_admin_management_by_admin_requires_caller_is_admin() {
     let setup = TestSetup::new();
     let non_admin = Address::generate(&setup.env);
     let new_admin = Address::generate(&setup.env);
 
     setup.mock_auth(&non_admin, "set_admin_by_admin_for_test", (&non_admin, &new_admin, true));
-    setup.client.set_admin_by_admin_for_test(&non_admin, &new_admin, &true);
+    assert_eq!(
+        setup.client.try_set_admin_by_admin_for_test(&non_admin, &new_admin, &true).unwrap_err().unwrap(),
+        WorkerError::Unauthorized.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotAllowed
+#[should_panic(expected = "Error(Contract, #1207)")] // WorkerError::NotAllowed
 fn test_assert_acl_rejects_when_not_allowed() {
     let setup = TestSetup::new();
     let allowed = Address::generate(&setup.env);
@@ -478,7 +500,7 @@ fn test_assert_acl_rejects_when_not_allowed() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1216)")] // WorkerError::UnsupportedMessageLib
+#[should_panic(expected = "Error(Contract, #1213)")] // WorkerError::UnsupportedMessageLib
 fn test_assert_supported_message_lib_rejects_unsupported() {
     let setup = TestSetup::new();
     let unsupported = Address::generate(&setup.env);
@@ -489,7 +511,7 @@ fn test_assert_supported_message_lib_rejects_unsupported() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1218)")] // WorkerError::WorkerIsPaused
+#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::WorkerIsPaused
 fn test_assert_not_paused_panics_when_paused() {
     let setup = TestSetup::new();