@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/Cargo.lock

@@ -1211,7 +1211,6 @@ dependencies = [
 name = "oapp-macros"
 version = "0.0.1"
 dependencies = [
- "heck 0.5.0",
  "insta",
  "prettyplease",
  "proc-macro2",
@@ -1437,6 +1436,17 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
+[[package]]
+name = "sac-manager"
+version = "0.0.1"
+dependencies = [
+ "cfg-if",
+ "common-macros",
+ "oft",
+ "soroban-sdk",
+ "utils",
+]
+
 [[package]]
 name = "schemars"
 version = "0.8.22"

package/contracts/common-macros/src/lib.rs

@@ -426,8 +426,6 @@ pub fn contract_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// Generated code includes:
 /// - `upgrade(env, new_wasm_hash)` - Upgrades the contract WASM (auth required)
 /// - `migrate(env, migration_data)` - Runs migration after upgrade (auth required, XDR-decodes `Bytes` to `MigrationData`)
-/// - `freeze(env)` - Permanently freezes the contract, preventing any future upgrades (auth required, irreversible)
-/// - `is_frozen(env)` - Returns whether the contract is frozen (upgrades disabled)
 /// - `contractmeta!` with `binver` set to the Cargo package version (if not 0.0.0)
 #[proc_macro_attribute]
 pub fn upgradeable(attr: TokenStream, item: TokenStream) -> TokenStream {

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__upgradeable__snapshot_generated_upgradeable_code.snap

@@ -1,5 +1,6 @@
 ---
 source: contracts/common-macros/src/tests/upgradeable.rs
+assertion_line: 80
 expression: combined
 ---
 // ============================================

package/contracts/endpoint-v2/src/messaging_channel.rs

@@ -154,7 +154,7 @@ impl EndpointV2 {
     ///
     /// # Returns
     /// * `nonce` - The next nonce for the path
-    pub(crate) fn outbound(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> u64 {
+    pub(super) fn outbound(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> u64 {
         let nonce = Self::outbound_nonce(env, sender, dst_eid, receiver) + 1;
         EndpointStorage::set_outbound_nonce(env, sender, dst_eid, receiver, &nonce);
         nonce
@@ -172,7 +172,7 @@ impl EndpointV2 {
     /// * `sender` - The sender OApp address on the source chain
     /// * `nonce` - The nonce of the message
     /// * `payload_hash` - The payload hash of the message (must not be empty payload hash)
-    pub(crate) fn inbound(
+    pub(super) fn inbound(
         env: &Env,
         receiver: &Address,
         src_eid: u32,
@@ -204,7 +204,7 @@ impl EndpointV2 {
     /// * `sender` - The sender OApp address on the source chain
     /// * `nonce` - The nonce of the message
     /// * `payload` - The payload of the message
-    pub(crate) fn clear_payload(
+    pub(super) fn clear_payload(
         env: &Env,
         receiver: &Address,
         src_eid: u32,
@@ -260,5 +260,34 @@ mod test {
         pub fn nil_payload_hash_for_test(env: &Env) -> BytesN<32> {
             Self::nil_payload_hash(env)
         }
+
+        /// Test-only wrapper for outbound.
+        pub fn outbound_for_test(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> u64 {
+            Self::outbound(env, sender, dst_eid, receiver)
+        }
+
+        /// Test-only wrapper for inbound.
+        pub fn inbound_for_test(
+            env: &Env,
+            receiver: &Address,
+            src_eid: u32,
+            sender: &BytesN<32>,
+            nonce: u64,
+            payload_hash: &BytesN<32>,
+        ) {
+            Self::inbound(env, receiver, src_eid, sender, nonce, payload_hash)
+        }
+
+        /// Test-only wrapper for clear_payload.
+        pub fn clear_payload_for_test(
+            env: &Env,
+            receiver: &Address,
+            src_eid: u32,
+            sender: &BytesN<32>,
+            nonce: u64,
+            payload: &Bytes,
+        ) {
+            Self::clear_payload(env, receiver, src_eid, sender, nonce, payload)
+        }
     }
 }

package/contracts/endpoint-v2/src/tests/endpoint_setup.rs

@@ -292,7 +292,7 @@ impl<'a> TestSetup<'a> {
         let env = &self.env;
         let endpoint_client = &self.endpoint_client;
         env.as_contract(&endpoint_client.address, || {
-            EndpointV2::inbound(env, receiver, src_eid, sender, nonce, payload_hash)
+            EndpointV2::inbound_for_test(env, receiver, src_eid, sender, nonce, payload_hash)
         });
     }
 }

package/contracts/endpoint-v2/src/tests/messaging_channel/clear_payload.rs

@@ -32,7 +32,7 @@ fn clear_payload(
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, receiver, src_eid, sender, nonce, payload)
+        EndpointV2::clear_payload_for_test(env, receiver, src_eid, sender, nonce, payload)
     });
 }
 

package/contracts/endpoint-v2/src/tests/messaging_channel/inbound.rs

@@ -16,7 +16,7 @@ fn test_inbound_success_stores_payload_hash() {
     let payload_hash = BytesN::from_array(env, &[0xabu8; 32]); // Valid non-empty payload hash
 
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce, &payload_hash)
     });
 
     let stored_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
@@ -26,7 +26,7 @@ fn test_inbound_success_stores_payload_hash() {
     let nonce2 = 2;
     let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
     });
     assert_eq!(
         endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce2),
@@ -37,7 +37,7 @@ fn test_inbound_success_stores_payload_hash() {
     let different_receiver = Address::generate(env);
     let payload_hash3 = BytesN::from_array(env, &[0xefu8; 32]);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &different_receiver, src_eid, &sender, nonce, &payload_hash3)
+        EndpointV2::inbound_for_test(env, &different_receiver, src_eid, &sender, nonce, &payload_hash3)
     });
     assert_eq!(
         endpoint_client.inbound_payload_hash(&different_receiver, &src_eid, &sender, &nonce),
@@ -61,7 +61,7 @@ fn test_inbound_overwrites_same_nonce() {
     let payload_hash_b = BytesN::from_array(env, &[0xcdu8; 32]);
 
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash_a)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce, &payload_hash_a)
     });
     assert_eq!(
         endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce),
@@ -70,7 +70,7 @@ fn test_inbound_overwrites_same_nonce() {
 
     // Overwrite the same nonce with a different payload hash.
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash_b)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce, &payload_hash_b)
     });
     assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash_b));
 }
@@ -89,6 +89,6 @@ fn test_inbound_rejects_empty_payload_hash() {
     let empty_hash = BytesN::from_array(env, &[0u8; 32]); // empty payload hash is invalid for inbound()
 
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &empty_hash)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce, &empty_hash)
     });
 }

package/contracts/endpoint-v2/src/tests/messaging_channel/inbound_payload_hash.rs

@@ -32,7 +32,7 @@ fn test_inbound_payload_hash_after_setting() {
 
     // Set payload hash using inbound function
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &expected_hash)
+        EndpointV2::inbound_for_test(env, &receiver, src_eid, &sender, nonce, &expected_hash)
     });
 
     // Verify payload hash is retrieved correctly

package/contracts/endpoint-v2/src/tests/messaging_channel/outbound.rs

@@ -14,33 +14,39 @@ fn test_outbound_increments_and_is_path_scoped() {
     let receiver = BytesN::from_array(env, &[1u8; 32]);
 
     // First call should return nonce 1
-    let nonce1 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    let nonce1 =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound_for_test(env, &sender, dst_eid, &receiver));
     assert_eq!(nonce1, 1);
 
     // Second call should return nonce 2
-    let nonce2 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    let nonce2 =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound_for_test(env, &sender, dst_eid, &receiver));
     assert_eq!(nonce2, 2);
 
     // Third call should return nonce 3
-    let nonce3 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    let nonce3 =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound_for_test(env, &sender, dst_eid, &receiver));
     assert_eq!(nonce3, 3);
 
     // Different sender should have independent nonce counter (starts at 1)
     let different_sender = Address::generate(env);
-    let nonce_diff_sender =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &different_sender, dst_eid, &receiver));
+    let nonce_diff_sender = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::outbound_for_test(env, &different_sender, dst_eid, &receiver)
+    });
     assert_eq!(nonce_diff_sender, 1);
 
     // Different dst_eid should have independent nonce counter (starts at 1)
     let different_dst_eid = 3;
-    let nonce_diff_dst =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, different_dst_eid, &receiver));
+    let nonce_diff_dst = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::outbound_for_test(env, &sender, different_dst_eid, &receiver)
+    });
     assert_eq!(nonce_diff_dst, 1);
 
     // Different receiver should have independent nonce counter (starts at 1)
     let different_receiver = BytesN::from_array(env, &[2u8; 32]);
-    let nonce_diff_receiver =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &different_receiver));
+    let nonce_diff_receiver = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::outbound_for_test(env, &sender, dst_eid, &different_receiver)
+    });
     assert_eq!(nonce_diff_receiver, 1);
 
     // Verify state was updated correctly for original path.
@@ -64,5 +70,5 @@ fn test_outbound_panics_on_u64_overflow() {
         storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &u64::MAX)
     });
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    env.as_contract(&endpoint_client.address, || EndpointV2::outbound_for_test(env, &sender, dst_eid, &receiver));
 }

package/contracts/macro-integration-tests/tests/runtime/oapp/options_type3.rs

@@ -1,8 +1,8 @@
 // Runtime tests: OAppOptionsType3 defaults generated by `#[oapp]`.
 
 use super::{TestOApp, TestOAppClient};
-use oapp::errors::OAppError;
 use oapp::oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet};
+use oapp::OAppError;
 use soroban_sdk::{
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     vec, Address, Bytes, Env, IntoVal,
@@ -29,15 +29,15 @@ fn enforced_options_lifecycle_and_auth() {
     let owner = Address::generate(&env);
     client.init(&owner, &Address::generate(&env));
 
-    // Unset returns empty bytes (storage default).
-    assert_eq!(client.enforced_options(&999, &999), Bytes::new(&env));
+    // Unset returns None (storage default).
+    assert_eq!(client.enforced_options(&999, &999), None);
 
     let enforced_1 = create_valid_options(&env, &[1, 2, 3, 4]);
     let enforced_2 = create_valid_options(&env, &[5, 6, 7, 8]);
     let params = vec![
         &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced_1.clone() },
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_RECEIVE, options: enforced_2.clone() },
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced_1.clone()) },
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_RECEIVE, options: Some(enforced_2.clone()) },
     ];
 
     // Unauthorized set should fail (only_auth).
@@ -68,10 +68,10 @@ fn enforced_options_lifecycle_and_auth() {
     }]);
     client.set_enforced_options(&params);
 
-    assert_contains_event(&env, &contract_id, EnforcedOptionSet { enforced_option_params: params.clone() });
+    assert_contains_event(&env, &contract_id, EnforcedOptionSet { enforced_options: params.clone() });
 
-    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), enforced_1);
-    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_RECEIVE), enforced_2);
+    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(enforced_1));
+    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_RECEIVE), Some(enforced_2));
 }
 
 #[test]
@@ -87,7 +87,7 @@ fn set_enforced_options_rejects_invalid_option_type() {
     let mut invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
     invalid.extend_from_slice(&[1, 2, 3]);
 
-    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: invalid }];
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(invalid) }];
 
     env.mock_auths(&[MockAuth {
         address: &owner,
@@ -120,7 +120,7 @@ fn combine_options_behavior_and_validation() {
     // Set enforced for (eid, msg_type).
     let enforced = create_valid_options(&env, &[1, 2, 3, 4]);
     let params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced.clone()) }];
     env.mock_auths(&[MockAuth {
         address: &owner,
         invoke: &MockAuthInvoke {

package/contracts/macro-integration-tests/tests/runtime/oapp/receiver.rs

@@ -2,7 +2,7 @@
 
 use super::{TestOApp, TestOAppClient};
 use endpoint_v2::Origin;
-use oapp::errors::OAppError;
+use oapp::OAppError;
 use soroban_sdk::{
     contract, contractimpl, symbol_short,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
@@ -264,7 +264,7 @@ fn lz_receive_wrong_peer_returns_only_peer() {
 }
 
 #[test]
-fn lz_receive_no_peer_returns_only_peer() {
+fn lz_receive_no_peer_returns_no_peer() {
     let env = Env::default();
 
     let owner = Address::generate(&env);
@@ -295,7 +295,7 @@ fn lz_receive_no_peer_returns_only_peer() {
     }]);
 
     let result = oapp_client.try_lz_receive(&executor, &origin, &guid, &message, &extra_data, &value);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::OnlyPeer.into());
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
 }
 
 #[test]

package/contracts/macro-integration-tests/tests/runtime/oapp/sender.rs

@@ -1,8 +1,9 @@
 // Runtime tests: OAppSenderInternal defaults generated by `#[oapp]`.
 
 use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
-use oapp::errors::OAppError;
 use oapp::oapp_receiver::LzReceiveInternal;
+use oapp::oapp_sender::FeePayer;
+use oapp::OAppError;
 use oapp_macros::oapp;
 use soroban_sdk::{
     contract, contractimpl, symbol_short,
@@ -93,7 +94,7 @@ impl LzReceiveInternal for TestOAppSender {
 #[contractimpl]
 impl TestOAppSender {
     pub fn init(env: Env, owner: Address, endpoint: Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(&env, &owner, &endpoint, &None::<Address>);
+        oapp::oapp_core::initialize_oapp::<Self>(&env, &owner, &endpoint, &owner);
     }
 
     pub fn quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
@@ -110,7 +111,7 @@ impl TestOAppSender {
         refund_address: &Address,
     ) -> MessagingReceipt {
         sender.require_auth();
-        Self::__lz_send(env, dst_eid, message, options, sender, fee, refund_address)
+        Self::__lz_send(env, dst_eid, message, options, &FeePayer::Verified(sender.clone()), fee, refund_address)
     }
 }
 

package/contracts/macro-integration-tests/tests/runtime/upgradeable/migrate_guard_and_state.rs

@@ -187,60 +187,7 @@ fn migrate_is_guarded_and_obeys_migrating_flag() {
 }
 
 #[test]
-fn freeze_is_guarded_and_blocks_upgrade() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    // Unauthorized freeze should fail.
-    let unauthorized = client.try_freeze();
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized freeze should succeed.
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "freeze",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .freeze();
-
-    env.as_contract(&contract_id, || {
-        assert_eq!(UpgradeableStorage::frozen(&env), true);
-    });
-
-    // After freeze, upgrade should fail with UpgradesFrozen (even with auth).
-    let hash = BytesN::<32>::from_array(&env, &[7u8; 32]);
-    let frozen_upgrade = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "upgrade",
-                args: (&hash,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_upgrade(&hash);
-
-    assert_eq!(
-        frozen_upgrade.err().unwrap().ok().unwrap(),
-        utils::errors::UpgradeableError::UpgradesFrozen.into()
-    );
-}
-
-#[test]
-fn upgrade_freeze_and_migrate_fail_before_owner_init() {
+fn upgrade_and_migrate_fail_before_owner_init() {
     let env = Env::default();
     let contract_id = env.register(TestContract, ());
     let client = TestContractClient::new(&env, &contract_id);
@@ -250,9 +197,6 @@ fn upgrade_freeze_and_migrate_fail_before_owner_init() {
     let hash = BytesN::<32>::from_array(&env, &[7u8; 32]);
     assert_eq!(client.try_upgrade(&hash).unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
 
-    // freeze() should also fail the same way.
-    assert_eq!(client.try_freeze().unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
-
     // Even if migrating is set, migrate() still fails before init because auth can't resolve authorizer.
     env.as_contract(&contract_id, || {
         UpgradeableStorage::set_migrating(&env, &true);

package/contracts/macro-integration-tests/tests/ui/lz_contract/fail/upgradeable_missing_internal.stderr

@@ -40,36 +40,6 @@ note: required by a bound in `migrate`
    |     fn migrate(env: &soroban_sdk::Env, migration_data: &soroban_sdk::Bytes) {
    |        ------- required by a bound in this associated function
 
-error[E0277]: the trait bound `MyContract: UpgradeableInternal` is not satisfied
-  --> tests/ui/lz_contract/fail/upgradeable_missing_internal.rs:12:12
-   |
-12 | pub struct MyContract;
-   |            ^^^^^^^^^^ the trait `UpgradeableInternal` is not implemented for `MyContract`
-   |
-note: required by a bound in `freeze`
-  --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-   |
-   | pub trait Upgradeable: UpgradeableInternal + Auth {
-   |                        ^^^^^^^^^^^^^^^^^^^ required by this bound in `Upgradeable::freeze`
-...
-   |     fn freeze(env: &soroban_sdk::Env) {
-   |        ------ required by a bound in this associated function
-
-error[E0277]: the trait bound `MyContract: UpgradeableInternal` is not satisfied
-  --> tests/ui/lz_contract/fail/upgradeable_missing_internal.rs:12:12
-   |
-12 | pub struct MyContract;
-   |            ^^^^^^^^^^ the trait `UpgradeableInternal` is not implemented for `MyContract`
-   |
-note: required by a bound in `is_frozen`
-  --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-   |
-   | pub trait Upgradeable: UpgradeableInternal + Auth {
-   |                        ^^^^^^^^^^^^^^^^^^^ required by this bound in `Upgradeable::is_frozen`
-...
-   |     fn is_frozen(env: &soroban_sdk::Env) -> bool {
-   |        --------- required by a bound in this associated function
-
 error[E0277]: the trait bound `MyContract: UpgradeableInternal` is not satisfied
   --> tests/ui/lz_contract/fail/upgradeable_missing_internal.rs:17:5
    |

package/contracts/macro-integration-tests/tests/ui/oapp/fail/custom_wrong_value.stderr

@@ -1,5 +1,7 @@
-error: expected square brackets
- --> tests/ui/oapp/fail/custom_wrong_value.rs:5:17
+error: custom attribute panicked
+ --> tests/ui/oapp/fail/custom_wrong_value.rs:5:1
   |
 5 | #[oapp(custom = core)]
-  |                 ^^^^
+  | ^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: failed to parse oapp attributes: expected square brackets

package/contracts/macro-integration-tests/tests/ui/oapp/fail/non_struct_input.stderr

@@ -1,5 +1,7 @@
-error: expected `struct`
- --> tests/ui/oapp/fail/non_struct_input.rs:6:5
+error: custom attribute panicked
+ --> tests/ui/oapp/fail/non_struct_input.rs:5:1
   |
-6 | pub enum NotAStruct {
-  |     ^^^^
+5 | #[oapp]
+  | ^^^^^^^
+  |
+  = help: message: failed to parse struct: expected `struct`

package/contracts/macro-integration-tests/tests/ui/oapp/fail/unknown_custom_option.stderr

@@ -1,5 +1,7 @@
-error: expected one of `core`, `sender`, `receiver`, `options_type3`
- --> tests/ui/oapp/fail/unknown_custom_option.rs:5:24
+error: custom attribute panicked
+ --> tests/ui/oapp/fail/unknown_custom_option.rs:5:1
   |
 5 | #[oapp(custom = [core, not_a_real_option])]
-  |                        ^^^^^^^^^^^^^^^^^
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: failed to parse oapp attributes: expected one of `core`, `sender`, `receiver`, `options_type3`

package/contracts/macro-integration-tests/tests/ui/oapp/fail/wrong_key.stderr

@@ -1,5 +1,7 @@
-error: expected `custom`
- --> tests/ui/oapp/fail/wrong_key.rs:5:8
+error: custom attribute panicked
+ --> tests/ui/oapp/fail/wrong_key.rs:5:1
   |
 5 | #[oapp(nope = [core])]
-  |        ^^^^
+  | ^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: failed to parse oapp attributes: expected `custom`

package/contracts/macro-integration-tests/tests/ui/upgradeable/fail/missing_auth_trait.stderr

@@ -39,33 +39,3 @@ note: required by a bound in `migrate`
 ...
    |     fn migrate(env: &soroban_sdk::Env, migration_data: &soroban_sdk::Bytes) {
    |        ------- required by a bound in this associated function
-
-error[E0277]: the trait bound `MyContract: utils::auth::Auth` is not satisfied
-  --> tests/ui/upgradeable/fail/missing_auth_trait.rs:12:12
-   |
-12 | pub struct MyContract;
-   |            ^^^^^^^^^^ the trait `utils::auth::Auth` is not implemented for `MyContract`
-   |
-note: required by a bound in `freeze`
-  --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-   |
-   | pub trait Upgradeable: UpgradeableInternal + Auth {
-   |                                              ^^^^ required by this bound in `Upgradeable::freeze`
-...
-   |     fn freeze(env: &soroban_sdk::Env) {
-   |        ------ required by a bound in this associated function
-
-error[E0277]: the trait bound `MyContract: utils::auth::Auth` is not satisfied
-  --> tests/ui/upgradeable/fail/missing_auth_trait.rs:12:12
-   |
-12 | pub struct MyContract;
-   |            ^^^^^^^^^^ the trait `utils::auth::Auth` is not implemented for `MyContract`
-   |
-note: required by a bound in `is_frozen`
-  --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-   |
-   | pub trait Upgradeable: UpgradeableInternal + Auth {
-   |                                              ^^^^ required by this bound in `Upgradeable::is_frozen`
-...
-   |     fn is_frozen(env: &soroban_sdk::Env) -> bool {
-   |        --------- required by a bound in this associated function

package/contracts/macro-integration-tests/tests/ui/upgradeable/fail/missing_upgradeable_internal.stderr

@@ -47,33 +47,3 @@ note: required by a bound in `migrate`
 ...
   |     fn migrate(env: &soroban_sdk::Env, migration_data: &soroban_sdk::Bytes) {
   |        ------- required by a bound in this associated function
-
-error[E0277]: the trait bound `MyContract: UpgradeableInternal` is not satisfied
- --> tests/ui/upgradeable/fail/missing_upgradeable_internal.rs:8:12
-  |
-8 | pub struct MyContract;
-  |            ^^^^^^^^^^ the trait `UpgradeableInternal` is not implemented for `MyContract`
-  |
-note: required by a bound in `freeze`
- --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-  |
-  | pub trait Upgradeable: UpgradeableInternal + Auth {
-  |                        ^^^^^^^^^^^^^^^^^^^ required by this bound in `Upgradeable::freeze`
-...
-  |     fn freeze(env: &soroban_sdk::Env) {
-  |        ------ required by a bound in this associated function
-
-error[E0277]: the trait bound `MyContract: UpgradeableInternal` is not satisfied
- --> tests/ui/upgradeable/fail/missing_upgradeable_internal.rs:8:12
-  |
-8 | pub struct MyContract;
-  |            ^^^^^^^^^^ the trait `UpgradeableInternal` is not implemented for `MyContract`
-  |
-note: required by a bound in `is_frozen`
- --> $WORKSPACE/contracts/utils/src/upgradeable.rs
-  |
-  | pub trait Upgradeable: UpgradeableInternal + Auth {
-  |                        ^^^^^^^^^^^^^^^^^^^ required by this bound in `Upgradeable::is_frozen`
-...
-  |     fn is_frozen(env: &soroban_sdk::Env) -> bool {
-  |        --------- required by a bound in this associated function

package/contracts/macro-integration-tests/tests/ui/upgradeable/pass/basic.rs

@@ -35,8 +35,6 @@ impl MyContract {
         // Type-check generated entrypoints.
         Self::upgrade(&env, &hash);
         Self::migrate(&env, &migration_data);
-        Self::freeze(&env);
-        let _frozen: bool = Self::is_frozen(&env);
     }
 }
 

package/contracts/macro-integration-tests/tests/ui/upgradeable/pass/multisig_contract.rs

@@ -27,8 +27,6 @@ impl MyContract {
         let migration_data = Bytes::new(&env);
         Self::upgrade(&env, &hash);
         Self::migrate(&env, &migration_data);
-        Self::freeze(&env);
-        let _frozen: bool = Self::is_frozen(&env);
     }
 }
 

package/contracts/macro-integration-tests/tests/ui/upgradeable/pass/no_migration.rs

@@ -22,8 +22,6 @@ impl MyContract {
         let migration_data = Bytes::new(&env);
         Self::upgrade(&env, &hash);
         Self::migrate(&env, &migration_data);
-        Self::freeze(&env);
-        let _frozen: bool = Self::is_frozen(&env);
     }
 }
 

package/contracts/macro-integration-tests/tests/ui/upgradeable/pass/no_user_contractimpl.rs

@@ -2,7 +2,7 @@
 //
 // Purpose:
 // - Ensures the macro-generated `impl utils::upgradeable::Upgradeable for Contract` is enough to
-//   provide the upgrade/migrate/freeze entrypoints.
+//   provide the upgrade/migrate entrypoints.
 // - Covers the common pattern where the contract does not define any custom entrypoints.
 
 use soroban_sdk::{contract, Address, Bytes, BytesN, Env};
@@ -22,8 +22,6 @@ fn typecheck(env: &Env, owner: &Address) {
     let migration_data = Bytes::new(env);
     MyContract::upgrade(env, &hash);
     MyContract::migrate(env, &migration_data);
-    MyContract::freeze(env);
-    let _frozen: bool = MyContract::is_frozen(env);
 }
 
 fn main() {}