@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/macro-integration-tests/tests/runtime/ttl_extendable/extend_instance_ttl.rs

@@ -0,0 +1,64 @@
+// Runtime tests: `#[ttl_extendable]` behavior (manual instance TTL extension).
+
+use super::{TestContract, TestContractClient};
+use soroban_sdk::testutils::{storage::Instance as _, Ledger as _};
+use soroban_sdk::Env;
+use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
+
+#[test]
+fn extend_instance_ttl_extends_instance_storage() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Ensure instance storage exists.
+    client.touch();
+
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    // Move ledger forward so current TTL equals a small number, then extend.
+    let threshold = 1u32;
+    env.ledger().set_sequence_number(live_until.saturating_sub(threshold));
+    let extend_to = threshold + 50;
+
+    client.extend_instance_ttl(&threshold, &extend_to);
+
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, extend_to);
+}
+
+#[test]
+fn extend_instance_ttl_does_not_auto_extend_from_config() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Ensure instance storage exists so TTL is meaningful.
+    client.touch();
+
+    // Capture current TTL and compute live_until.
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    // Configure an instance TTL auto-extension config that would trigger at threshold=10 and extend to before+100.
+    // NOTE: `#[ttl_extendable]` intentionally uses `#[soroban_sdk::contractimpl]` (not `common_macros::contract_impl`),
+    // so calling `extend_instance_ttl` should NOT also run any auto-TTL extension logic.
+    let cfg = TtlConfig::new(10, before + 100);
+    env.as_contract(&contract_id, || {
+        TtlConfigStorage::set_instance(&env, &cfg);
+    });
+
+    // Move ledger so current TTL equals cfg.threshold (this is the would-be auto-extension trigger point).
+    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold));
+
+    // Call manual extension with a threshold that should NOT trigger (0), regardless of extend_to.
+    client.extend_instance_ttl(&0, &9999);
+
+    // If auto-extension were incorrectly injected, TTL would become cfg.extend_to.
+    // Instead, it should remain at the current TTL (cfg.threshold).
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, cfg.threshold);
+}

package/contracts/macro-integration-tests/tests/runtime/ttl_extendable/mod.rs

@@ -0,0 +1,16 @@
+use soroban_sdk::{contract, Env};
+
+mod extend_instance_ttl;
+
+/// Shared contract used by ttl_extendable runtime tests.
+#[contract]
+#[common_macros::ttl_extendable]
+pub struct TestContract;
+
+#[soroban_sdk::contractimpl]
+impl TestContract {
+    pub fn touch(env: Env) {
+        // Create some instance storage state so instance TTL is meaningful.
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "touched"), &true);
+    }
+}

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

@@ -0,0 +1,305 @@
+// Runtime tests: `#[upgradeable]` + `#[only_auth]` behavior and migration state wiring.
+//
+// We avoid exercising `env.deployer().update_current_contract_wasm(...)` directly by setting
+// the migrating flag via storage; the purpose here is to verify macro-generated wiring:
+// - `upgrade`/`migrate` are generated as contract entrypoints
+// - both are guarded by `#[only_auth]`
+// - `migrate` delegates to `utils::upgradeable::migrate::<Self>` with correct MigrationData
+
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::ToXdr,
+    xdr::{ScErrorCode, ScErrorType},
+    Address, Bytes, BytesN, Env, Error, IntoVal, Val,
+};
+use utils::upgradeable::{UpgradeableInternal, UpgradeableStorage};
+use utils::errors::OwnableError;
+
+// A small, known-good contract WASM used for upgrade() testing.
+// Sourced from the `upgrader` crate test fixtures.
+const TEST_UPGRADE_WASM: &[u8] =
+    include_bytes!("../../../../upgrader/src/tests/test_data/test_upgradeable_contract1.wasm");
+
+#[contract]
+#[common_macros::ownable]
+#[common_macros::upgradeable]
+pub struct TestContract;
+
+impl UpgradeableInternal for TestContract {
+    type MigrationData = u32;
+
+    fn __migrate(env: &Env, _migration_data: &Self::MigrationData) {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(env, "migrated"), &true);
+        env.storage().instance().set(&soroban_sdk::Symbol::new(env, "migration_data"), _migration_data);
+    }
+}
+
+#[contractimpl]
+impl TestContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+}
+
+#[test]
+fn upgrade_is_guarded_by_only_auth() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let attacker = Address::generate(&env);
+    client.init(&owner);
+
+    // Unauthorized call should fail (guard triggers before any upgrade body work).
+    let hash = BytesN::<32>::from_array(&env, &[7u8; 32]);
+    let unauthorized = client.try_upgrade(&hash);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Wrong-address auth should also fail (auth must be provided by the current owner).
+    let wrong_auth = client
+        .mock_auths(&[MockAuth {
+            address: &attacker,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "upgrade",
+                args: (&hash,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_upgrade(&hash);
+    assert_eq!(
+        wrong_auth.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+}
+
+#[test]
+fn upgrade_sets_migrating_flag_with_auth() {
+    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);
+
+    // Upload a real contract WASM so update_current_contract_wasm succeeds.
+    let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_UPGRADE_WASM));
+
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "upgrade",
+                args: (&wasm_hash,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .upgrade(&wasm_hash);
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+}
+
+#[test]
+fn migrate_is_guarded_and_obeys_migrating_flag() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let attacker = Address::generate(&env);
+    client.init(&owner);
+    let data: u32 = 7;
+    let migration_data = data.to_xdr(&env);
+
+    // Unauthorized migrate should fail.
+    let unauthorized = client.try_migrate(&migration_data);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized migrate without migrating flag should fail with UpgradeableError.
+    let result = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&migration_data,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_migrate(&migration_data);
+    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::UpgradeableError::MigrationNotAllowed.into());
+
+    // Even with migrating flag set, wrong-address auth should fail.
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+    });
+    let wrong_auth = client
+        .mock_auths(&[MockAuth {
+            address: &attacker,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&migration_data,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_migrate(&migration_data);
+    assert_eq!(
+        wrong_auth.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Set migrating flag directly, then migrate should succeed and clear the flag + run __migrate.
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+    });
+
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&migration_data,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .migrate(&migration_data);
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), false);
+        let migrated: Option<bool> = env.storage().instance().get(&soroban_sdk::Symbol::new(&env, "migrated"));
+        assert_eq!(migrated, Some(true));
+        let stored: Option<u32> = env.storage().instance().get(&soroban_sdk::Symbol::new(&env, "migration_data"));
+        assert_eq!(stored, Some(data));
+    });
+}
+
+#[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() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Without owner initialization, authorizer lookup fails (OwnableError::OwnerNotSet),
+    // which should surface as a contract error (not Context/InvalidAction).
+    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);
+    });
+    let migration_data = 1u32.to_xdr(&env);
+    assert_eq!(
+        client.try_migrate(&migration_data).unwrap_err().unwrap(),
+        OwnableError::OwnerNotSet.into()
+    );
+}
+
+#[test]
+fn migrate_rejects_invalid_migration_data_and_does_not_clear_flag() {
+    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);
+
+    // Allow migrate, then pass invalid bytes (not XDR for u32).
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+    });
+
+    // Provide auth and pass bytes that are valid XDR but *not* a u32 payload.
+    // Using a stable Bytes object avoids mock-arg matching pitfalls.
+    let bad_bytes = Val::VOID.to_xdr(&env);
+    let res = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&bad_bytes,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_migrate(&bad_bytes);
+
+    assert_eq!(
+        res.err().unwrap().ok().unwrap(),
+        utils::errors::UpgradeableError::InvalidMigrationData.into()
+    );
+
+    // Since migration failed before reaching the "clear flag" line, migrating should still be true.
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+}

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

@@ -0,0 +1,3 @@
+mod migrate_guard_and_state;
+mod no_migration;
+mod upgrade_then_migrate;

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

@@ -0,0 +1,59 @@
+// Runtime tests: `#[upgradeable(no_migration)]` macro variant.
+//
+// This ensures the macro-generated default `UpgradeableInternal` impl works end-to-end at runtime
+// (i.e. no manual impl required), and that migrate clears the migrating flag.
+
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::ToXdr,
+    Address, Env, IntoVal,
+};
+use utils::upgradeable::UpgradeableStorage;
+
+#[contract]
+#[common_macros::ownable]
+#[common_macros::upgradeable(no_migration)]
+pub struct NoMigrationContract;
+
+#[contractimpl]
+impl NoMigrationContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+}
+
+#[test]
+fn no_migration_contract_can_migrate_and_clears_flag() {
+    let env = Env::default();
+    let contract_id = env.register(NoMigrationContract, ());
+    let client = NoMigrationContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    // Allow migrate.
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+    });
+
+    // The no_migration impl uses MigrationData = (), so we pass XDR bytes for ().
+    let migration_data = ().to_xdr(&env);
+
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&migration_data,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .migrate(&migration_data);
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), false);
+    });
+}
+

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

@@ -0,0 +1,88 @@
+// Runtime tests: complete upgrade -> migrate flow.
+//
+// Note: `upgrade()` swaps the contract WASM, so the `migrate()` invocation that follows is
+// executed in the *upgraded* WASM. This test therefore uses `MigrationData = ()` to match the
+// upgradeable WASM fixture used in this repo.
+
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::ToXdr,
+    Address, Bytes, Env, IntoVal,
+};
+use utils::upgradeable::{UpgradeableInternal, UpgradeableStorage};
+
+// Upgrade target WASM fixture.
+const TEST_UPGRADE_WASM: &[u8] =
+    include_bytes!("../../../../upgrader/src/tests/test_data/test_upgradeable_contract1.wasm");
+
+#[contract]
+#[common_macros::ownable]
+#[common_macros::upgradeable]
+pub struct FlowContract;
+
+impl UpgradeableInternal for FlowContract {
+    type MigrationData = ();
+
+    fn __migrate(env: &Env, _migration_data: &Self::MigrationData) {
+        // Marker in case the upgraded WASM delegates back to our migrate logic.
+        env.storage().instance().set(&soroban_sdk::Symbol::new(env, "flow_migrated"), &true);
+    }
+}
+
+#[contractimpl]
+impl FlowContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+}
+
+#[test]
+fn upgrade_then_migrate_happy_path() {
+    let env = Env::default();
+    let contract_id = env.register(FlowContract, ());
+    let client = FlowContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    // Upload a real contract WASM so update_current_contract_wasm succeeds.
+    let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_UPGRADE_WASM));
+
+    // upgrade() should set migrating=true.
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "upgrade",
+                args: (&wasm_hash,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .upgrade(&wasm_hash);
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+
+    // migrate() should be allowed after upgrade and should clear migrating back to false.
+    // The upgraded WASM fixture expects XDR-encoded migration data bytes.
+    // (This fixture is shared with `upgrader` tests which pass a u32 migration payload.)
+    let migration_data = 1u32.to_xdr(&env);
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "migrate",
+                args: (&migration_data,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .migrate(&migration_data);
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), false);
+    });
+}

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

@@ -1,6 +1,11 @@
 mod runtime {
+    mod contract_ttl;
+    mod lz_contract;
+    mod multisig;
     mod oapp;
     mod ownable;
     mod storage;
     mod ttl_configurable;
+    mod ttl_extendable;
+    mod upgradeable;
 }

package/contracts/macro-integration-tests/tests/ui/contract_impl/fail/not_impl_item.rs

@@ -0,0 +1,6 @@
+// UI (trybuild) negative test: `#[contract_impl]` must be applied to an `impl` block.
+
+#[common_macros::contract_impl]
+pub fn not_an_impl() {}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/contract_impl/fail/not_impl_item.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/contract_impl/fail/not_impl_item.rs:3:1
+  |
+3 | #[common_macros::contract_impl]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: failed to parse impl block: expected `impl`

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

@@ -0,0 +1,102 @@
+// UI (trybuild) test: `#[contract_impl]` on an impl block compiles.
+//
+// Purpose:
+// - Verifies `#[common_macros::contract_impl]` can wrap a `impl MyContract { ... }` block.
+// - Covers the "pass" surface area:
+//   - Inherent impls: only **public** methods with an `Env` parameter are instrumented.
+//   - Trait impls: **all** methods with an `Env` parameter are instrumented.
+//   - Methods without `Env` are skipped.
+//   - `__constructor` is instrumented to initialize default TTL configs.
+//   - `Env` can be passed by `&Env` or `Env` (and must be the first param for soroban `contractimpl`).
+
+use soroban_sdk::{contract, contracttrait, Env};
+
+#[contract]
+pub struct MyContract;
+
+#[common_macros::contract_impl]
+impl MyContract {
+    // Public method with `&Env` (instrumented).
+    pub fn ping(env: &Env) {
+        let _ = env;
+    }
+
+    // Public method with `Env` by value (instrumented).
+    pub fn ping_owned(env: Env) {
+        let _ = env;
+    }
+
+    // Public method with extra args (still instrumented).
+    pub fn ping_with_args(env: Env, x: u32) -> u32 {
+        let _ = &env;
+        x
+    }
+
+    // Public method with a fully-qualified Env path (instrumented).
+    pub fn ping_fq_env(env: &soroban_sdk::Env) {
+        let _ = env;
+    }
+
+    // Public method without `Env` (skipped).
+    pub fn no_env(x: u32) -> u32 {
+        x
+    }
+
+    // Constructor is instrumented to initialize default TTL configs.
+    // This contract covers the `Env`-by-value variant.
+    pub fn __constructor(env: Env) {
+        let _ = env;
+    }
+
+    // Non-public methods in inherent impls are skipped (should still compile).
+    fn private_with_env(env: &Env) {
+        let _ = env;
+    }
+
+    // `pub(crate)` is also non-public in syn::Visibility terms (skipped in inherent impls).
+    pub(crate) fn crate_visible_with_env(env: &Env) {
+        let _ = env;
+    }
+}
+
+#[contract]
+pub struct MyContractCtorRef;
+
+#[common_macros::contract_impl]
+impl MyContractCtorRef {
+    // Constructor is instrumented to initialize default TTL configs.
+    // This contract covers the `&Env` variant.
+    pub fn __constructor(env: &Env) {
+        let _ = env;
+    }
+
+    // Include at least one regular entrypoint to ensure the impl is still processed.
+    pub fn ping_ref(env: &Env) {
+        let _ = env;
+    }
+
+    pub fn ping(env: Env) {
+        let _ = env;
+    }
+}
+
+// A neutral multi-method trait impl to better exercise the "trait impl branch"
+#[contracttrait]
+pub trait UiTraitImplBranch {
+    fn t1(env: &Env);
+    fn t2(env: &Env, x: u32) -> u32;
+}
+
+#[common_macros::contract_impl(contracttrait)]
+impl UiTraitImplBranch for MyContract {
+    fn t1(env: &Env) {
+        let _ = env;
+    }
+
+    fn t2(env: &Env, x: u32) -> u32 {
+        let _ = env;
+        x
+    }
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/contract_trait/fail/not_a_trait.rs

@@ -0,0 +1,6 @@
+// UI (trybuild) negative test: `#[contract_trait]` must be applied to a trait.
+
+#[common_macros::contract_trait]
+pub struct NotATrait;
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/contract_trait/fail/not_a_trait.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/contract_trait/fail/not_a_trait.rs:3:1
+  |
+3 | #[common_macros::contract_trait]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: failed to parse trait definition: expected `trait`