@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -1,77 +1,162 @@
 use soroban_sdk::{Bytes, Env};
 
 use crate::bytes_ext::BytesExt;
+use crate::tests::test_helper::assert_panics_contains;
+
+// ============================================
+// Helper functions
+// ============================================
+
+/// Helper to assert that `to_array::<N>()` panics with BytesExtError::LengthMismatch (1400)
+fn assert_to_array_panics<const N: usize>(case: &str, raw: &[u8]) {
+    const EXPECTED: &str = "Error(Contract, #1400)";
+    assert_panics_contains(case, EXPECTED, || {
+        let env = Env::default();
+        let bytes = Bytes::from_slice(&env, raw);
+        let _arr: [u8; N] = bytes.to_array();
+    });
+}
+
+// ============================================
+// Successful conversion tests
+// ============================================
 
 #[test]
-fn test_to_array_exact_length() {
+fn test_to_array_various_sizes() {
     let env = Env::default();
-    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
-
-    let arr: [u8; 4] = bytes.to_array();
 
-    assert_eq!(arr, [0x01, 0x02, 0x03, 0x04]);
-}
+    // Empty array
+    let bytes = Bytes::from_array(&env, &[]);
+    let arr: [u8; 0] = bytes.to_array();
+    let expected: [u8; 0] = [];
+    assert_eq!(arr, expected);
 
-#[test]
-fn test_to_array_single_byte() {
-    let env = Env::default();
+    // Single byte
     let bytes = Bytes::from_array(&env, &[0xAB]);
+    assert_eq!(bytes.to_array::<1>(), [0xAB]);
 
-    let arr: [u8; 1] = bytes.to_array();
+    // Two bytes
+    let bytes = Bytes::from_array(&env, &[0xAB, 0xCD]);
+    assert_eq!(bytes.to_array::<2>(), [0xAB, 0xCD]);
 
-    assert_eq!(arr, [0xAB]);
-}
+    // Four bytes
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    assert_eq!(bytes.to_array::<4>(), [0x01, 0x02, 0x03, 0x04]);
 
-#[test]
-fn test_to_array_preserves_order() {
-    let env = Env::default();
+    // Eight bytes - verify order preserved
     let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
-
-    let arr: [u8; 8] = bytes.to_array();
-
-    // Verify bytes are in correct order (big-endian preservation)
+    let arr = bytes.to_array::<8>();
     assert_eq!(arr[0], 0x01);
     assert_eq!(arr[7], 0x08);
+
+    // 32 bytes
+    let data: [u8; 32] = [0x42; 32];
+    let bytes = Bytes::from_array(&env, &data);
+    assert_eq!(bytes.to_array::<32>(), data);
+
+    // 64 bytes
+    let data: [u8; 64] = core::array::from_fn(|i| i as u8);
+    let bytes = Bytes::from_array(&env, &data);
+    assert_eq!(bytes.to_array::<64>(), data);
 }
 
 #[test]
-#[should_panic]
-fn test_to_array_length_mismatch_too_short() {
+fn test_to_array_boundary_values() {
     let env = Env::default();
-    // Bytes has 3 elements, but trying to convert to [u8; 4]
-    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03]);
 
-    let _arr: [u8; 4] = bytes.to_array();
+    // All zeros
+    let data: [u8; 16] = [0x00; 16];
+    let bytes = Bytes::from_array(&env, &data);
+    let arr: [u8; 16] = bytes.to_array();
+    assert_eq!(arr, data);
+
+    // All ones
+    let data: [u8; 16] = [0xFF; 16];
+    let bytes = Bytes::from_array(&env, &data);
+    let arr: [u8; 16] = bytes.to_array();
+    assert_eq!(arr, data);
+
+    // Boundary byte values
+    let bytes = Bytes::from_array(&env, &[0x00, 0x7F, 0x80, 0xFF]);
+    let arr: [u8; 4] = bytes.to_array();
+    assert_eq!(arr[0], 0x00); // min
+    assert_eq!(arr[1], 0x7F); // max positive signed
+    assert_eq!(arr[2], 0x80); // min negative signed
+    assert_eq!(arr[3], 0xFF); // max
+
+    // Sequential values
+    let data: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    let bytes = Bytes::from_array(&env, &data);
+    let arr: [u8; 10] = bytes.to_array();
+    for i in 0..10 {
+        assert_eq!(arr[i], i as u8);
+    }
+}
+
+// ============================================
+// Length mismatch tests (error conditions)
+// ============================================
+
+#[test]
+fn test_to_array_length_mismatch_panics_table() {
+    // Bytes too short
+    assert_to_array_panics::<4>("3 bytes to [u8; 4]", &[0x01, 0x02, 0x03]);
+    // Bytes too long
+    assert_to_array_panics::<4>("5 bytes to [u8; 4]", &[0x01, 0x02, 0x03, 0x04, 0x05]);
+    // Empty to non-empty
+    assert_to_array_panics::<4>("0 bytes to [u8; 4]", &[]);
+    // Off-by-one short
+    assert_to_array_panics::<8>("7 bytes to [u8; 8]", &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
+    // Off-by-one long
+    assert_to_array_panics::<8>("9 bytes to [u8; 8]", &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09]);
+    // Significantly wrong size
+    assert_to_array_panics::<32>("4 bytes to [u8; 32]", &[0x01, 0x02, 0x03, 0x04]);
 }
 
 #[test]
-#[should_panic]
-fn test_to_array_length_mismatch_too_long() {
+fn test_to_array_large_sizes() {
     let env = Env::default();
-    // Bytes has 5 elements, but trying to convert to [u8; 4]
-    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05]);
 
-    let _arr: [u8; 4] = bytes.to_array();
+    // Test with 128 bytes
+    let data: [u8; 128] = core::array::from_fn(|i| (i % 256) as u8);
+    let bytes = Bytes::from_array(&env, &data);
+    assert_eq!(bytes.to_array::<128>(), data);
+
+    // Test with 256 bytes
+    let data: [u8; 256] = core::array::from_fn(|i| (i % 256) as u8);
+    let bytes = Bytes::from_array(&env, &data);
+    assert_eq!(bytes.to_array::<256>(), data);
 }
 
 #[test]
-#[should_panic]
-fn test_to_array_empty_to_non_empty() {
+fn test_to_array_very_large_size() {
     let env = Env::default();
-    let bytes = Bytes::from_array(&env, &[]);
 
-    // Trying to convert empty bytes to non-empty array should panic
-    let _arr: [u8; 4] = bytes.to_array();
+    // Test with 512 bytes to ensure it works beyond 256
+    let data: [u8; 512] = core::array::from_fn(|i| (i % 256) as u8);
+    let bytes = Bytes::from_array(&env, &data);
+    let arr = bytes.to_array::<512>();
+
+    // Verify first and last elements
+    assert_eq!(arr[0], 0);
+    assert_eq!(arr[255], 255);
+    assert_eq!(arr[256], 0);
+    assert_eq!(arr[511], 255);
+
+    // Verify full array matches
+    assert_eq!(arr, data);
 }
 
 #[test]
-fn test_to_array_empty_to_empty() {
+fn test_to_array_preserves_all_values() {
     let env = Env::default();
-    let bytes = Bytes::from_array(&env, &[]);
 
-    // Converting empty bytes to empty array should work
-    let arr: [u8; 0] = bytes.to_array();
-    let expected: [u8; 0] = [];
+    // Test that all byte values (0-255) are preserved correctly
+    let data: [u8; 256] = core::array::from_fn(|i| i as u8);
+    let bytes = Bytes::from_array(&env, &data);
+    let arr: [u8; 256] = bytes.to_array();
 
-    assert_eq!(arr, expected);
+    for i in 0..256 {
+        assert_eq!(arr[i], i as u8, "Mismatch at index {}", i);
+    }
 }

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

@@ -2,3 +2,6 @@ mod buffer_reader;
 mod buffer_writer;
 mod bytes_ext;
 mod ownable;
+mod test_helper;
+mod testing_utils;
+mod ttl;

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

@@ -1,6 +1,9 @@
 use crate::{
     errors::OwnableError,
-    ownable::{self, DefaultOwnable, DefaultOwnableStorage, Ownable, OwnershipTransferred},
+    ownable::{
+        self, DefaultOwnable, DefaultOwnableStorage, Ownable, OwnableInitializer, OwnershipRenounced,
+        OwnershipTransferred,
+    },
     testing_utils::assert_event,
 };
 use soroban_sdk::{
@@ -23,8 +26,8 @@ impl Contract {
         1
     }
 
-    pub fn remove_owner_no_auth(env: &Env) {
-        DefaultOwnableStorage::remove_owner(env);
+    pub fn enforce_and_return_owner(env: &Env) -> Address {
+        ownable::enforce_owner_auth::<Self>(env)
     }
 
     pub fn init_owner(env: &Env, owner: &Address) {
@@ -33,6 +36,10 @@ impl Contract {
         }
         DefaultOwnableStorage::set_owner(env, owner);
     }
+
+    pub fn remove_owner(env: &Env) {
+        DefaultOwnableStorage::remove_owner(env);
+    }
 }
 
 #[contractimpl]
@@ -50,14 +57,32 @@ impl Ownable for Contract {
     }
 }
 
+/// Contract that does not implement Ownable trait - for testing raw init_owner
+#[contract]
+pub struct NonOwnableContract;
+
+#[contractimpl]
+impl NonOwnableContract {
+    pub fn init(env: &Env, owner: &Address) {
+        DefaultOwnable::init_owner(env, owner);
+    }
+
+    pub fn owner(env: &Env) -> Option<Address> {
+        DefaultOwnable::owner(env)
+    }
+}
+
+// ============================================
+// auth: Owner authentication tests
+// ============================================
+
 #[test]
-fn test_owner_can_call() {
+fn auth_owner_can_call() {
     let env = Env::default();
-
     let owner = Address::generate(&env);
 
     let contract = env.register(Contract, (&owner,));
-    let contract_client = ContractClient::new(&env, &contract);
+    let client = ContractClient::new(&env, &contract);
 
     env.mock_auths(&[MockAuth {
         address: &owner,
@@ -68,32 +93,58 @@ fn test_owner_can_call() {
             sub_invokes: &[],
         },
     }]);
-    contract_client.require_owner_auth();
+    client.require_owner_auth();
 }
 
 #[test]
 #[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_non_owner_cannot_call() {
+fn auth_non_owner_cannot_call() {
     let env = Env::default();
-
     let owner = Address::generate(&env);
     let contract = env.register(Contract, (&owner,));
-    let contract_client = ContractClient::new(&env, &contract);
+    let client = ContractClient::new(&env, &contract);
 
-    contract_client.require_owner_auth();
+    // Try to call without auth should fail
+    client.require_owner_auth();
 }
 
 #[test]
-fn test_transfer_ownership() {
+#[should_panic(expected = "Error(Contract, #1301)")]
+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();
+}
+
+// ============================================
+// transfer: Transfer ownership tests
+// ============================================
 
+#[test]
+fn transfer_ownership_with_event() {
+    let env = Env::default();
     let owner = Address::generate(&env);
     let new_owner = Address::generate(&env);
 
     let contract = env.register(Contract, (&owner,));
-    let contract_client = ContractClient::new(&env, &contract);
+    let client = ContractClient::new(&env, &contract);
+
+    assert_eq!(client.owner(), Some(owner.clone()));
 
-    assert_eq!(contract_client.owner(), Some(owner.clone()));
     env.mock_auths(&[MockAuth {
         address: &owner,
         invoke: &MockAuthInvoke {
@@ -103,47 +154,348 @@ fn test_transfer_ownership() {
             sub_invokes: &[],
         },
     }]);
-    contract_client.transfer_ownership(&new_owner);
+    client.transfer_ownership(&new_owner);
 
     assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+    assert_eq!(client.owner(), Some(new_owner));
+}
+
+#[test]
+fn transfer_ownership_to_same_owner() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    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: &[],
+        },
+    }]);
+    client.transfer_ownership(&owner);
+
+    // Should still emit event and update (even if same owner)
+    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner.clone(), new_owner: owner.clone() });
+    assert_eq!(client.owner(), Some(owner));
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn transfer_ownership_requires_auth() {
+    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);
 
-    // assert owner
-    assert_eq!(contract_client.owner(), Some(new_owner.clone()));
+    // Try to transfer without auth should fail
+    client.transfer_ownership(&new_owner);
 }
 
 #[test]
-fn test_call_no_owner_set() {
+#[should_panic(expected = "Error(Contract, #1301)")]
+fn transfer_after_renounce_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);
+
+    // Renounce ownership
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "renounce_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    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);
+}
+
+// ============================================
+// renounce: Renounce ownership tests
+// ============================================
+
+#[test]
+fn renounce_ownership_with_event() {
+    let env = Env::default();
     let owner = Address::generate(&env);
 
     let contract = env.register(Contract, (&owner,));
-    let contract_client = ContractClient::new(&env, &contract);
-    contract_client.remove_owner_no_auth();
+    let client = ContractClient::new(&env, &contract);
+
+    assert_eq!(client.owner(), Some(owner.clone()));
 
     env.mock_auths(&[MockAuth {
         address: &owner,
         invoke: &MockAuthInvoke {
             contract: &contract,
             args: ().into_val(&env),
-            fn_name: "require_owner_auth",
+            fn_name: "renounce_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.renounce_ownership();
+
+    assert_event(&env, &contract, OwnershipRenounced { old_owner: owner });
+    assert_eq!(client.owner(), None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn renounce_ownership_requires_auth() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Try to renounce without auth should fail
+    client.renounce_ownership();
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1301)")]
+fn renounce_after_renounce_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    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: &[],
+        },
+    }]);
+    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: &[],
         },
     }]);
-    let result = contract_client.try_require_owner_auth();
-    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
+    client.renounce_ownership();
+}
+
+// ============================================
+// chain: Ownership chain tests
+// ============================================
+
+#[test]
+fn chain_new_owner_can_transfer() {
+    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);
+
+    // 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: &[],
+        },
+    }]);
+    client.transfer_ownership(&new_owner);
+
+    // 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: &[],
+        },
+    }]);
+    client.transfer_ownership(&third_owner);
+
+    assert_eq!(client.owner(), Some(third_owner));
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn chain_old_owner_cannot_transfer_after_transfer() {
+    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);
+
+    // 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: &[],
+        },
+    }]);
+    client.transfer_ownership(&new_owner);
+
+    // Old owner tries to transfer again - should fail
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&third_owner,).into_val(&env),
+            fn_name: "transfer_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.transfer_ownership(&third_owner);
+}
+
+// ============================================
+// init: DefaultOwnable::init_owner tests
+// ============================================
+
+#[test]
+fn init_owner_success() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let contract = env.register(NonOwnableContract, ());
+    let client = NonOwnableContractClient::new(&env, &contract);
+
+    assert_eq!(client.owner(), None);
+    client.init(&owner);
+    assert_eq!(client.owner(), Some(owner));
 }
 
 #[test]
-fn test_set_owner_when_already_set() {
+#[should_panic(expected = "Error(Contract, #1300)")]
+fn init_owner_already_set_fails() {
     let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let contract = env.register(NonOwnableContract, ());
+    let client = NonOwnableContractClient::new(&env, &contract);
+
+    client.init(&owner);
+    client.init(&new_owner);
+}
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1300)")]
+fn init_owner_when_already_set_fails() {
+    let env = Env::default();
     let owner = Address::generate(&env);
     let new_owner = Address::generate(&env);
 
     let contract = env.register(Contract, (&owner,));
-    let contract_client = ContractClient::new(&env, &contract);
+    let client = ContractClient::new(&env, &contract);
+
+    client.init_owner(&new_owner);
+}
+
+// ============================================
+// enforce: enforce_owner_auth tests
+// ============================================
+
+#[test]
+fn enforce_owner_auth_returns_owner() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    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: &[],
+        },
+    }]);
+
+    let returned_owner = client.enforce_and_return_owner();
+    assert_eq!(returned_owner, owner);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1301)")]
+fn enforce_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();
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "enforce_and_return_owner",
+            sub_invokes: &[],
+        },
+    }]);
+
+    client.enforce_and_return_owner();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn enforce_owner_auth_wrong_address_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let wrong_address = Address::generate(&env);
+    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: &[],
+        },
+    }]);
 
-    let result = contract_client.try_init_owner(&new_owner);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerAlreadySet.into());
+    client.enforce_and_return_owner();
 }