@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/contracts/utils/src/tests/option_ext.rs

@@ -1,9 +1,6 @@
+use crate::{errors::OwnableError, option_ext::OptionExt, tests::test_helper::assert_panics_contains};
 use soroban_sdk::Env;
 
-use crate::{errors::OwnableError, option_ext::OptionExt};
-
-use crate::tests::test_helper::assert_panics_contains;
-
 #[test]
 fn unwrap_or_panic_some_returns_value() {
     let env = Env::default();
@@ -13,7 +10,7 @@ fn unwrap_or_panic_some_returns_value() {
 
 #[test]
 fn unwrap_or_panic_none_panics_with_error() {
-    const EXPECTED: &str = "Error(Contract, #1301)";
+    const EXPECTED: &str = "Error(Contract, #1034)"; // OwnerNotSet
     assert_panics_contains("none unwrap_or_panic", EXPECTED, || {
         let env = Env::default();
         let _got: u32 = None::<u32>.unwrap_or_panic(&env, OwnableError::OwnerNotSet);

package/contracts/utils/src/tests/ownable.rs

@@ -1,5 +1,11 @@
 use crate::{
-    ownable::{self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred},
+    auth::Auth,
+    errors::OwnableError,
+    option_ext::OptionExt,
+    ownable::{
+        self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred,
+        OwnershipTransferring,
+    },
     testing_utils::assert_event,
 };
 use soroban_sdk::{
@@ -35,6 +41,14 @@ impl Contract {
     }
 }
 
+/// Auth implementation for the test contract - uses stored owner as authorizer.
+#[contractimpl]
+impl Auth for Contract {
+    fn authorizer(env: &Env) -> Address {
+        <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
+    }
+}
+
 #[contractimpl(contracttrait)]
 impl Ownable for Contract {}
 impl OwnableInitializer for Contract {}
@@ -76,7 +90,7 @@ fn auth_non_owner_cannot_call() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn auth_require_owner_when_no_owner_set() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -98,7 +112,7 @@ fn auth_require_owner_when_no_owner_set() {
 }
 
 // ============================================
-// transfer: Transfer ownership tests
+// transfer: Single-step transfer ownership tests
 // ============================================
 
 #[test]
@@ -154,7 +168,7 @@ fn transfer_ownership_to_same_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn transfer_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -188,6 +202,343 @@ fn transfer_after_renounce_fails() {
     client.transfer_ownership(&new_owner);
 }
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+fn transfer_ownership_blocked_during_2step() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let another_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try single-step transfer - should fail
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&another_owner,).into_val(&env),
+            fn_name: "transfer_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.transfer_ownership(&another_owner);
+}
+
+// ============================================
+// transfer_2step: Two-step transfer ownership tests
+// ============================================
+
+#[test]
+fn propose_ownership_transfer_initiate_and_accept() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    assert_eq!(client.owner(), Some(owner.clone()));
+    assert_eq!(client.pending_owner(), None);
+
+    // Step 1: Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    assert_event(
+        &env,
+        &contract,
+        OwnershipTransferring { old_owner: owner.clone(), new_owner: new_owner.clone(), ttl },
+    );
+    assert_eq!(client.owner(), Some(owner.clone())); // Still old owner
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+
+    // Step 2: Accept transfer
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+    assert_eq!(client.owner(), Some(new_owner)); // Now new owner
+    assert_eq!(client.pending_owner(), None);
+}
+
+#[test]
+fn propose_ownership_transfer_cancel() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+
+    // Cancel transfer (ttl = 0)
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &0u32);
+
+    // No event emitted on cancel (matching OpenZeppelin behavior)
+    assert_eq!(client.owner(), Some(owner)); // Still old owner
+    assert_eq!(client.pending_owner(), None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+fn propose_ownership_transfer_cancel_no_pending_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Try to cancel when no transfer is pending
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &0u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1030)")] // InvalidPendingOwner
+fn propose_ownership_transfer_cancel_wrong_address_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let wrong_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to cancel with wrong address
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&wrong_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&wrong_owner, &0u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1031)")] // InvalidTtl
+fn propose_ownership_transfer_invalid_ttl_exceeds_max_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // TTL that would exceed max_live_until_ledger
+    let ttl = u32::MAX;
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+fn accept_ownership_no_pending_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Try to accept when no transfer is pending
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn accept_ownership_wrong_address_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let wrong_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to accept with wrong address
+    env.mock_auths(&[MockAuth {
+        address: &wrong_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+}
+
+#[test]
+fn propose_ownership_transfer_override_pending() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner1 = Address::generate(&env);
+    let new_owner2 = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate first transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner1, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner1, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner1.clone()));
+
+    // Override with second transfer (allowed - replaces pending)
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner2, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner2, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner2.clone()));
+
+    // new_owner2 can accept
+    env.mock_auths(&[MockAuth {
+        address: &new_owner2,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_eq!(client.owner(), Some(new_owner2));
+}
+
 // ============================================
 // renounce: Renounce ownership tests
 // ============================================
@@ -218,7 +569,7 @@ fn renounce_ownership_with_event() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn renounce_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -251,6 +602,43 @@ fn renounce_after_renounce_fails() {
     client.renounce_ownership();
 }
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+fn renounce_blocked_during_2step_transfer() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to renounce - should fail
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "renounce_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.renounce_ownership();
+}
+
 // ============================================
 // chain: Ownership chain tests
 // ============================================
@@ -292,12 +680,73 @@ fn chain_new_owner_can_transfer() {
     assert_eq!(client.owner(), Some(third_owner));
 }
 
+#[test]
+fn chain_new_owner_can_transfer_2step() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let third_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // 2-step transfer to new_owner
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    // new_owner can now do another 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&third_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&third_owner, &ttl);
+
+    env.mock_auths(&[MockAuth {
+        address: &third_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_eq!(client.owner(), Some(third_owner));
+}
+
 // ============================================
 // init: DefaultOwnable::init_owner tests
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1300)")]
+#[should_panic(expected = "Error(Contract, #1033)")] // OwnerAlreadySet
 fn reinit_owner_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -334,7 +783,7 @@ fn enforce_owner_auth_returns_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn enforce_owner_auth_no_owner_set_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);

package/contracts/utils/src/tests/ttl_configurable.rs

@@ -1,10 +1,14 @@
 extern crate std;
 
-use crate::errors::TtlConfigurableError;
-use crate::ownable::OwnableInitializer;
-use crate::testing_utils::assert_event;
-use crate::ttl_configurable::{
-    TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
+use crate::{
+    auth::Auth,
+    errors::{OwnableError, TtlConfigurableError},
+    option_ext::OptionExt,
+    ownable::{Ownable, OwnableInitializer},
+    testing_utils::assert_event,
+    ttl_configurable::{
+        TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
+    },
 };
 use soroban_sdk::{
     contract, contractimpl,
@@ -90,11 +94,18 @@ impl TtlTestContract {
     }
 }
 
-// Enable the default `TtlConfigurable` implementation (which requires `Ownable`) on the test contract.
+// Enable the default `TtlConfigurable` implementation (which requires `Auth`) on the test contract.
 //
 // Note: use plain Rust `impl` (not `#[contractimpl(contracttrait)]`) to avoid generating
-// duplicate Soroban contract entrypoints that would collide with this test contract’s helpers.
-impl crate::ownable::Ownable for TtlTestContract {}
+// duplicate Soroban contract entrypoints that would collide with this test contract's helpers.
+
+/// Auth implementation for test contract - uses the stored owner as authorizer.
+impl Auth for TtlTestContract {
+    fn authorizer(env: &soroban_sdk::Env) -> Address {
+        <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
+    }
+}
+impl Ownable for TtlTestContract {}
 impl OwnableInitializer for TtlTestContract {}
 impl TtlConfigurable for TtlTestContract {}
 
@@ -369,7 +380,7 @@ fn test_default_ttl_configurable_freeze() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1201)")]
+#[should_panic(expected = "Error(Contract, #1021)")] // TtlConfigFrozen
 fn test_default_ttl_configurable_set_when_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -382,7 +393,7 @@ fn test_default_ttl_configurable_set_when_frozen() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1202)")]
+#[should_panic(expected = "Error(Contract, #1022)")] // TtlConfigAlreadyFrozen
 fn test_default_ttl_configurable_freeze_when_already_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -412,7 +423,7 @@ fn test_default_ttl_configurable_freeze_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_freeze_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -430,7 +441,7 @@ fn test_default_ttl_configurable_freeze_when_owner_not_set() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_instance_config() {
     let (env, contract_id, owner, client) = setup_contract();
     // threshold > extend_to is invalid
@@ -441,7 +452,7 @@ fn test_default_ttl_configurable_invalid_instance_config() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_persistent_config() {
     let (env, contract_id, owner, client) = setup_contract();
     let invalid_cfg = TtlConfig::new(5000, 4000);
@@ -451,7 +462,7 @@ fn test_default_ttl_configurable_invalid_persistent_config() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_exceeds_max_ttl() {
     let (env, contract_id, owner, client) = setup_contract();
     let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
@@ -518,7 +529,7 @@ fn test_default_ttl_configurable_set_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_set_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -534,7 +545,7 @@ fn test_default_ttl_configurable_set_when_owner_not_set() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
+#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_exceeds_effective_max_ttl() {
     let (env, contract_id, owner, client) = setup_contract();
 

package/contracts/utils/src/tests/upgradeable.rs

@@ -256,7 +256,7 @@ fn test_migrate_success() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1500)")]
+#[should_panic(expected = "Error(Contract, #1050)")] // MigrationNotAllowed
 fn test_migrate_fail_without_upgrade() {
     let env = Env::default();
     let contract_id = env.register(DummyContract, ());
@@ -271,14 +271,16 @@ fn test_migrate_fail_without_upgrade() {
 // Integration test: upgrade then migrate
 // ============================================
 
+// TODO (ken): change error code to 1050 and fix test
 #[test]
-#[should_panic(expected = "Error(Contract, #1500)")]
+#[should_panic(expected = "Error(Contract, #1500)")] // MigrationNotAllowed (TEST_WASM uses old error code)
 fn test_cannot_migrate_twice_without_upgrade() {
     let env = Env::default();
     let contract_id = env.register(DummyContract, ());
     let client = DummyContractClient::new(&env, &contract_id);
 
     // First upgrade and migrate with valid WASM
+    // Note: TEST_WASM is a pre-compiled contract with old error codes (1500 instead of 1050)
     let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_WASM));
     client.upgrade(&wasm_hash);
     client.migrate(&());