@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -7,10 +7,11 @@ use crate::{
         OwnershipTransferring,
     },
     testing_utils::assert_eq_event,
+    tests::test_helper::mock_auth,
 };
 use soroban_sdk::{
     contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    testutils::{storage::Temporary as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
     Address, Env, IntoVal,
 };
 
@@ -23,11 +24,6 @@ impl Contract {
         Self::init_owner(env, owner);
     }
 
-    pub fn require_owner_auth(env: &Env) -> u32 {
-        ownable::require_owner_auth::<Self>(env);
-        1
-    }
-
     pub fn enforce_and_return_owner(env: &Env) -> Address {
         ownable::enforce_owner_auth::<Self>(env)
     }
@@ -65,16 +61,8 @@ fn auth_owner_can_call() {
     let contract = env.register(Contract, (&owner,));
     let client = ContractClient::new(&env, &contract);
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "require_owner_auth",
-            sub_invokes: &[],
-        },
-    }]);
-    client.require_owner_auth();
+    mock_auth(&env, &contract, &owner, "enforce_and_return_owner", ());
+    client.enforce_and_return_owner();
 }
 
 #[test]
@@ -86,29 +74,7 @@ fn auth_non_owner_cannot_call() {
     let client = ContractClient::new(&env, &contract);
 
     // Try to call without auth should fail
-    client.require_owner_auth();
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
-fn auth_require_owner_when_no_owner_set() {
-    let env = Env::default();
-    let owner = Address::generate(&env);
-
-    let contract = env.register(Contract, (&owner,));
-    let client = ContractClient::new(&env, &contract);
-    client.remove_owner();
-
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "require_owner_auth",
-            sub_invokes: &[],
-        },
-    }]);
-    client.require_owner_auth();
+    client.enforce_and_return_owner();
 }
 
 // ============================================
@@ -126,15 +92,7 @@ fn transfer_ownership_with_event() {
 
     assert_eq!(client.owner(), Some(owner.clone()));
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: (&new_owner,).into_val(&env),
-            fn_name: "transfer_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "transfer_ownership", (&new_owner,));
     client.transfer_ownership(&new_owner);
 
     assert_eq_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
@@ -151,15 +109,7 @@ fn transfer_ownership_to_same_owner() {
 
     assert_eq!(client.owner(), Some(owner.clone()));
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: (&owner,).into_val(&env),
-            fn_name: "transfer_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "transfer_ownership", (&owner,));
     client.transfer_ownership(&owner);
 
     // Should still emit event and update (even if same owner)
@@ -168,7 +118,6 @@ fn transfer_ownership_to_same_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn transfer_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -178,32 +127,32 @@ fn transfer_after_renounce_fails() {
     let client = ContractClient::new(&env, &contract);
 
     // Renounce ownership
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "renounce_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "renounce_ownership", ());
     client.renounce_ownership();
 
     // Try to transfer after renounce - should fail with OwnerNotSet
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: (&new_owner,).into_val(&env),
-            fn_name: "transfer_ownership",
-            sub_invokes: &[],
-        },
-    }]);
-    client.transfer_ownership(&new_owner);
+    mock_auth(&env, &contract, &owner, "transfer_ownership", (&new_owner,));
+    let result = client.try_transfer_ownership(&new_owner);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn transfer_ownership_non_owner_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let non_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Non-owner tries to transfer with their own auth - should fail
+    mock_auth(&env, &contract, &non_owner, "transfer_ownership", (&non_owner,));
+    client.transfer_ownership(&non_owner);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1036)")] // TransferInProgress
 fn transfer_ownership_blocked_during_2step() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -295,6 +244,49 @@ fn propose_ownership_transfer_initiate_and_accept() {
     assert_eq!(client.pending_owner(), None);
 }
 
+#[test]
+fn pending_owner_expires_after_ttl() {
+    let env = Env::default();
+    env.ledger().set_sequence_number(1_000);
+
+    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 = 10u32;
+
+    // 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()));
+
+    // Advance ledger beyond the actual storage TTL window; temporary pending owner entry should expire.
+    // Note: `extend_ttl` cannot reduce TTL, so the effective TTL can be >= the requested `ttl`.
+    let (ttl_before, seq_before) = env.as_contract(&contract, || {
+        (env.storage().temporary().get_ttl(&OwnableStorage::PendingOwner), env.ledger().sequence())
+    });
+    assert!(ttl_before >= ttl, "pending owner TTL must be at least requested ttl");
+
+    let live_until = seq_before + ttl_before;
+    env.ledger().set_sequence_number(live_until + 1);
+
+    assert_eq!(client.pending_owner(), None);
+
+    // Accept should now fail with NoPendingTransfer (expired).
+    let res = client.try_accept_ownership();
+    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::NoPendingTransfer.into());
+}
+
 #[test]
 fn propose_ownership_transfer_cancel() {
     let env = Env::default();
@@ -338,7 +330,40 @@ fn propose_ownership_transfer_cancel() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+fn propose_ownership_transfer_with_max_ttl() {
+    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);
+
+    // Use max TTL
+    let max_ttl = env.storage().max_ttl();
+    // Initiate transfer with max TTL
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, max_ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &max_ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+
+    // Get the actual TTL of the pending_owner entry
+    let actual_ttl = env.as_contract(&contract, || env.storage().temporary().get_ttl(&OwnableStorage::PendingOwner));
+
+    // The actual TTL should be at least the requested TTL
+    // To see the value, temporarily use: assert_eq!(actual_ttl, 0);
+    assert!(actual_ttl == max_ttl, "TTL should be max_ttl");
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1033)")] // NoPendingTransfer
 fn propose_ownership_transfer_cancel_no_pending_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -361,7 +386,7 @@ fn propose_ownership_transfer_cancel_no_pending_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1030)")] // InvalidPendingOwner
+#[should_panic(expected = "Error(Contract, #1031)")] // InvalidPendingOwner
 fn propose_ownership_transfer_cancel_wrong_address_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -399,7 +424,7 @@ fn propose_ownership_transfer_cancel_wrong_address_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // InvalidTtl
+#[should_panic(expected = "Error(Contract, #1032)")] // InvalidTtl
 fn propose_ownership_transfer_invalid_ttl_exceeds_max_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -409,7 +434,7 @@ fn propose_ownership_transfer_invalid_ttl_exceeds_max_fails() {
     let client = ContractClient::new(&env, &contract);
 
     // TTL that would exceed max_live_until_ledger
-    let ttl = u32::MAX;
+    let ttl = env.storage().max_ttl() + 1;
 
     env.mock_auths(&[MockAuth {
         address: &owner,
@@ -420,11 +445,12 @@ fn propose_ownership_transfer_invalid_ttl_exceeds_max_fails() {
             sub_invokes: &[],
         },
     }]);
+
     client.propose_ownership_transfer(&new_owner, &ttl);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+#[should_panic(expected = "Error(Contract, #1033)")] // NoPendingTransfer
 fn accept_ownership_no_pending_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -553,15 +579,7 @@ fn renounce_ownership_with_event() {
 
     assert_eq!(client.owner(), Some(owner.clone()));
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "renounce_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "renounce_ownership", ());
     client.renounce_ownership();
 
     assert_eq_event(&env, &contract, OwnershipRenounced { old_owner: owner });
@@ -569,7 +587,6 @@ fn renounce_ownership_with_event() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn renounce_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -578,32 +595,32 @@ fn renounce_after_renounce_fails() {
     let client = ContractClient::new(&env, &contract);
 
     // Renounce ownership
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "renounce_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "renounce_ownership", ());
     client.renounce_ownership();
 
     // Try to renounce again - should fail with OwnerNotSet
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "renounce_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "renounce_ownership", ());
+    let result = client.try_renounce_ownership();
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn renounce_ownership_non_owner_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let non_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Non-owner tries to renounce with their own auth - should fail
+    mock_auth(&env, &contract, &non_owner, "renounce_ownership", ());
     client.renounce_ownership();
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+#[should_panic(expected = "Error(Contract, #1036)")] // TransferInProgress
 fn renounce_blocked_during_2step_transfer() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -654,27 +671,16 @@ fn chain_new_owner_can_transfer() {
     let client = ContractClient::new(&env, &contract);
 
     // Transfer to new_owner
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: (&new_owner,).into_val(&env),
-            fn_name: "transfer_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "transfer_ownership", (&new_owner,));
     client.transfer_ownership(&new_owner);
 
+    // Verify old owner cannot call anymore
+    mock_auth(&env, &contract, &owner, "enforce_and_return_owner", ());
+    let result = client.try_enforce_and_return_owner();
+    assert!(result.is_err(), "old owner should not be able to call after transfer");
+
     // new_owner can now transfer to third_owner
-    env.mock_auths(&[MockAuth {
-        address: &new_owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: (&third_owner,).into_val(&env),
-            fn_name: "transfer_ownership",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &new_owner, "transfer_ownership", (&third_owner,));
     client.transfer_ownership(&third_owner);
 
     assert_eq!(client.owner(), Some(third_owner));
@@ -746,7 +752,6 @@ fn chain_new_owner_can_transfer_2step() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1033)")] // OwnerAlreadySet
 fn reinit_owner_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -754,7 +759,8 @@ fn reinit_owner_fails() {
     let contract = env.register(Contract, (&owner,));
     let client = ContractClient::new(&env, &contract);
 
-    client.reinit_owner(&new_owner);
+    let result = client.try_reinit_owner(&new_owner);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerAlreadySet.into());
 }
 
 // ============================================
@@ -768,22 +774,13 @@ fn enforce_owner_auth_returns_owner() {
     let contract = env.register(Contract, (&owner,));
     let client = ContractClient::new(&env, &contract);
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "enforce_and_return_owner",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &owner, "enforce_and_return_owner", ());
 
     let returned_owner = client.enforce_and_return_owner();
     assert_eq!(returned_owner, owner);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn enforce_owner_auth_no_owner_set_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -792,17 +789,23 @@ fn enforce_owner_auth_no_owner_set_fails() {
 
     client.remove_owner();
 
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "enforce_and_return_owner",
-            sub_invokes: &[],
-        },
-    }]);
+    // Even with auth, enforce_owner_auth must fail because no owner is set in storage.
+    mock_auth(&env, &contract, &owner, "enforce_and_return_owner", ());
+    let result = client.try_enforce_and_return_owner();
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
+}
 
-    client.enforce_and_return_owner();
+#[test]
+fn require_owner_auth_no_owner_set_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    client.remove_owner();
+
+    let result = client.try_enforce_and_return_owner();
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
 }
 
 #[test]
@@ -814,15 +817,7 @@ fn enforce_owner_auth_wrong_address_fails() {
     let contract = env.register(Contract, (&owner,));
     let client = ContractClient::new(&env, &contract);
 
-    env.mock_auths(&[MockAuth {
-        address: &wrong_address,
-        invoke: &MockAuthInvoke {
-            contract: &contract,
-            args: ().into_val(&env),
-            fn_name: "enforce_and_return_owner",
-            sub_invokes: &[],
-        },
-    }]);
+    mock_auth(&env, &contract, &wrong_address, "enforce_and_return_owner", ());
 
     client.enforce_and_return_owner();
 }

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

@@ -1,7 +1,11 @@
 // `utils` crate is `#![no_std]`, but unit tests can use `std`.
 extern crate std;
 
-use soroban_sdk::{address_payload::AddressPayload, BytesN};
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    testutils::{MockAuth, MockAuthInvoke},
+    Address, BytesN, Env, IntoVal, Val,
+};
 
 /// Same style as `common-macros` tests helper.
 pub(in crate::tests) fn assert_panics_contains<F>(case: &str, expected_substring: &str, f: F)
@@ -45,3 +49,19 @@ pub(in crate::tests) fn assert_address_payload_matches(actual: BytesN<32>, expec
         }
     }
 }
+
+/// Test helper to mock a single contract invocation auth.
+///
+/// This keeps test files from repeating `env.mock_auths(&[MockAuth { ... }])` blocks.
+pub(in crate::tests) fn mock_auth<A: IntoVal<Env, soroban_sdk::Vec<Val>>>(
+    env: &Env,
+    contract_id: &Address,
+    address: &Address,
+    fn_name: &'static str,
+    args: A,
+) {
+    env.mock_auths(&[MockAuth {
+        address,
+        invoke: &MockAuthInvoke { contract: contract_id, args: args.into_val(env), fn_name, sub_invokes: &[] },
+    }]);
+}

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

@@ -1,5 +1,12 @@
-use crate::testing_utils::{assert_contains_event, assert_contains_events, assert_eq_event, assert_eq_events};
-use soroban_sdk::{contract, contractevent, contractimpl, testutils::Address as _, Address, Env};
+extern crate std;
+
+use crate::testing_utils::{
+    assert_contains_event, assert_contains_events, assert_eq_event, assert_eq_events, decode_event_topics_data,
+};
+use soroban_sdk::{
+    contract, contractevent, contractimpl, testutils::Address as _, testutils::Events as _, xdr, Address, Env,
+    TryFromVal,
+};
 
 // ============================================
 // Test Fixtures
@@ -215,6 +222,41 @@ fn test_assert_event_data_mismatch() {
     assert_eq_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
 }
 
+// ============================================
+// decode_event_topics_data
+// ============================================
+
+#[test]
+fn test_decode_event_topics_data_roundtrip() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event2(&123, &456);
+
+    let filtered = env.events().all().filter_by_contract(&contract_id);
+    let raw = filtered.events();
+    assert_eq!(raw.len(), 1);
+
+    let event = &raw[0];
+    let v0 = match &event.body {
+        xdr::ContractEventBody::V0(v0) => v0,
+    };
+
+    let (topics, data) = decode_event_topics_data(&env, event).expect("event should decode");
+
+    // `Val` doesn't implement `PartialEq` in this SDK version, so compare by converting back to XDR.
+    let topics_xdr: std::vec::Vec<xdr::ScVal> =
+        topics.iter().map(|t| xdr::ScVal::try_from_val(&env, &t).expect("topic Val must convert to XDR")).collect();
+    assert_eq!(topics_xdr.len(), v0.topics.len() as usize);
+    for (i, t) in v0.topics.iter().enumerate() {
+        assert_eq!(topics_xdr[i], *t);
+    }
+
+    let data_xdr = xdr::ScVal::try_from_val(&env, &data).expect("data Val must convert to XDR");
+    assert_eq!(data_xdr, v0.data);
+}
+
 // ============================================
 // assert_eq_events
 // ============================================
@@ -438,3 +480,43 @@ fn test_assert_events_data_mismatch() {
 
     assert_eq_events(&env, &contract_id, &[&TestEvent2 { name: 100, count: 999 }]);
 }
+
+// ============================================
+// assert_contains_event / assert_contains_events (multiset semantics)
+// ============================================
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_contains_event_not_found_panics() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 999 });
+}
+
+#[test]
+fn test_assert_contains_events_allows_duplicates() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&42, &42);
+
+    assert_contains_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
+}
+
+#[test]
+#[should_panic(expected = "Expected event #1 not found")]
+fn test_assert_contains_events_duplicate_expected_but_not_emitted_panics() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    // Only one emission, but two expectations -> must fail on the second.
+    assert_contains_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
+}