@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,330 @@
+use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, Bytes, BytesN, Env, U256};
+
+use crate::buffer_reader::BufferReader;
+use crate::buffer_writer::BufferWriter;
+
+#[test]
+fn test_new_buffer_writer() {
+    let env = Env::default();
+    let writer = BufferWriter::new(&env);
+
+    assert_eq!(writer.len(), 0);
+    assert!(writer.is_empty());
+}
+
+#[test]
+fn test_write_u8() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u8(0x42);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 1);
+    assert_eq!(bytes.get(0).unwrap(), 0x42);
+}
+
+#[test]
+fn test_write_u16() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u16(0x1234);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 2);
+    assert_eq!(bytes.get(0).unwrap(), 0x12);
+    assert_eq!(bytes.get(1).unwrap(), 0x34);
+}
+
+#[test]
+fn test_write_u32() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u32(0x12345678);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 4);
+    assert_eq!(bytes.get(0).unwrap(), 0x12);
+    assert_eq!(bytes.get(1).unwrap(), 0x34);
+    assert_eq!(bytes.get(2).unwrap(), 0x56);
+    assert_eq!(bytes.get(3).unwrap(), 0x78);
+}
+
+#[test]
+fn test_write_u64() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u64(0x0102030405060708);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 8);
+    assert_eq!(bytes.get(0).unwrap(), 0x01);
+    assert_eq!(bytes.get(7).unwrap(), 0x08);
+}
+
+#[test]
+fn test_write_u128() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u128(200000u128);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 16);
+}
+
+#[test]
+fn test_write_u256() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    let value = U256::from_u32(&env, 0x12345678);
+    writer.write_u256(value);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 32);
+}
+
+#[test]
+fn test_write_bool_true() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_bool(true);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 1);
+    assert_eq!(bytes.get(0).unwrap(), 1);
+}
+
+#[test]
+fn test_write_bool_false() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_bool(false);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 1);
+    assert_eq!(bytes.get(0).unwrap(), 0);
+}
+
+#[test]
+fn test_write_bytes() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    let data = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    writer.write_bytes(&data);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 4);
+    assert_eq!(bytes.get(0).unwrap(), 0x01);
+    assert_eq!(bytes.get(3).unwrap(), 0x04);
+}
+
+#[test]
+fn test_write_bytes_n() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    let data: [u8; 32] = [0x42; 32];
+    let bytes32 = BytesN::<32>::from_array(&env, &data);
+    writer.write_bytes_n(&bytes32);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 32);
+    assert_eq!(bytes.get(0).unwrap(), 0x42);
+    assert_eq!(bytes.get(31).unwrap(), 0x42);
+}
+
+#[test]
+fn test_write_bytes_n_different_sizes() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    // Write BytesN<4>
+    let bytes4 = BytesN::<4>::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    writer.write_bytes_n(&bytes4);
+
+    // Write BytesN<8>
+    let bytes8 = BytesN::<8>::from_array(&env, &[0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c]);
+    writer.write_bytes_n(&bytes8);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 12); // 4 + 8
+    assert_eq!(bytes.get(0).unwrap(), 0x01);
+    assert_eq!(bytes.get(4).unwrap(), 0x05);
+}
+
+#[test]
+fn test_write_address_contract() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    // Generate a contract address
+    let address = Address::generate(&env);
+    let payload = address.to_payload().unwrap();
+    assert!(matches!(payload, AddressPayload::ContractIdHash(_)));
+
+    writer.write_address(&address);
+
+    // Address is 33 bytes (1 type + 32 payload)
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 33);
+}
+
+#[test]
+fn test_write_address_account() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    // Create an account address
+    let account_payload = BytesN::<32>::from_array(&env, &[0x42; 32]);
+    let address = Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(account_payload));
+    let payload = address.to_payload().unwrap();
+    assert!(matches!(payload, AddressPayload::AccountIdPublicKeyEd25519(_)));
+
+    writer.write_address(&address);
+
+    // Address is 33 bytes (1 type + 32 payload)
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 33);
+}
+
+#[test]
+fn test_write_address_roundtrip() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    let address = Address::generate(&env);
+    writer.write_address(&address);
+
+    let bytes = writer.to_bytes();
+    let mut reader = BufferReader::new(&bytes);
+    let read_address = reader.read_address();
+
+    // Verify round-trip
+    assert_eq!(read_address, address);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_chaining() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer.write_u8(0x01).write_u16(0x0203).write_u32(0x04050607);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 1 + 2 + 4); // 7 bytes total
+}
+
+#[test]
+fn test_from_bytes() {
+    let env = Env::default();
+    let initial = Bytes::from_array(&env, &[0x01, 0x02]);
+    let mut writer = BufferWriter::from_bytes(initial);
+
+    writer.write_u8(0x03);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 3);
+    assert_eq!(bytes.get(0).unwrap(), 0x01);
+    assert_eq!(bytes.get(1).unwrap(), 0x02);
+    assert_eq!(bytes.get(2).unwrap(), 0x03);
+}
+
+// Round-trip tests: write -> read
+#[test]
+fn test_roundtrip_primitives() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer
+        .write_u8(0x12)
+        .write_u16(0x3456)
+        .write_u32(0x789ABCDE)
+        .write_u64(0x0102030405060708)
+        .write_bool(true)
+        .write_bool(false);
+
+    let bytes = writer.to_bytes();
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_u8(), 0x12);
+    assert_eq!(reader.read_u16(), 0x3456);
+    assert_eq!(reader.read_u32(), 0x789ABCDE);
+    assert_eq!(reader.read_u64(), 0x0102030405060708);
+    assert!(reader.read_bool());
+    assert!(!reader.read_bool());
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_roundtrip_address() {
+    let env = Env::default();
+
+    // Generate address
+    let original_address = Address::generate(&env);
+
+    // Write
+    let mut writer = BufferWriter::new(&env);
+    writer.write_address(&original_address);
+    let bytes = writer.to_bytes();
+
+    // Read
+    let mut reader = BufferReader::new(&bytes);
+    let read_address = reader.read_address();
+
+    // Verify round-trip
+    assert_eq!(read_address, original_address);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_roundtrip_bytes_n() {
+    let env = Env::default();
+
+    let original: [u8; 32] = [
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
+        0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+    ];
+    let original_bytes32 = BytesN::<32>::from_array(&env, &original);
+
+    // Write
+    let mut writer = BufferWriter::new(&env);
+    writer.write_bytes_n(&original_bytes32);
+    let bytes = writer.to_bytes();
+
+    // Read
+    let mut reader = BufferReader::new(&bytes);
+    let read_bytes32 = reader.read_bytes_n::<32>();
+
+    // Verify round-trip
+    assert_eq!(read_bytes32, original_bytes32);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_roundtrip_u256() {
+    let env = Env::default();
+
+    let original = U256::from_u32(&env, 0x12345678);
+
+    // Write
+    let mut writer = BufferWriter::new(&env);
+    writer.write_u256(original.clone());
+    let bytes = writer.to_bytes();
+
+    // Read
+    let mut reader = BufferReader::new(&bytes);
+    let read_value = reader.read_u256();
+
+    // Verify round-trip
+    assert_eq!(read_value, original);
+    assert_eq!(reader.remaining(), 0);
+}

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

@@ -0,0 +1,77 @@
+use soroban_sdk::{Bytes, Env};
+
+use crate::bytes_ext::BytesExt;
+
+#[test]
+fn test_to_array_exact_length() {
+    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]);
+}
+
+#[test]
+fn test_to_array_single_byte() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xAB]);
+
+    let arr: [u8; 1] = bytes.to_array();
+
+    assert_eq!(arr, [0xAB]);
+}
+
+#[test]
+fn test_to_array_preserves_order() {
+    let env = Env::default();
+    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)
+    assert_eq!(arr[0], 0x01);
+    assert_eq!(arr[7], 0x08);
+}
+
+#[test]
+#[should_panic]
+fn test_to_array_length_mismatch_too_short() {
+    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();
+}
+
+#[test]
+#[should_panic]
+fn test_to_array_length_mismatch_too_long() {
+    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]
+#[should_panic]
+fn test_to_array_empty_to_non_empty() {
+    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]
+fn test_to_array_empty_to_empty() {
+    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] = [];
+
+    assert_eq!(arr, expected);
+}

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

@@ -0,0 +1,4 @@
+mod buffer_reader;
+mod buffer_writer;
+mod bytes_ext;
+mod ownable;

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

@@ -0,0 +1,149 @@
+use crate::{
+    errors::OwnableError,
+    ownable::{self, DefaultOwnable, DefaultOwnableStorage, Ownable, OwnershipTransferred},
+    testing_utils::assert_event,
+};
+use soroban_sdk::{
+    contract, contractimpl, panic_with_error,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Env, IntoVal,
+};
+
+#[contract]
+pub struct Contract;
+
+#[contractimpl]
+impl Contract {
+    pub fn __constructor(env: &Env, owner: &Address) {
+        Self::init_owner(env, owner);
+    }
+
+    pub fn require_owner_auth(env: &Env) -> u32 {
+        ownable::require_owner_auth::<Self>(env);
+        1
+    }
+
+    pub fn remove_owner_no_auth(env: &Env) {
+        DefaultOwnableStorage::remove_owner(env);
+    }
+
+    pub fn init_owner(env: &Env, owner: &Address) {
+        if DefaultOwnableStorage::has_owner(env) {
+            panic_with_error!(env, OwnableError::OwnerAlreadySet);
+        }
+        DefaultOwnableStorage::set_owner(env, owner);
+    }
+}
+
+#[contractimpl]
+impl Ownable for Contract {
+    fn owner(env: &Env) -> Option<Address> {
+        DefaultOwnable::owner(env)
+    }
+
+    fn transfer_ownership(env: &Env, new_owner: &Address) {
+        DefaultOwnable::transfer_ownership(env, new_owner);
+    }
+
+    fn renounce_ownership(env: &Env) {
+        DefaultOwnable::renounce_ownership(env);
+    }
+}
+
+#[test]
+fn test_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);
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "require_owner_auth",
+            sub_invokes: &[],
+        },
+    }]);
+    contract_client.require_owner_auth();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_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);
+
+    contract_client.require_owner_auth();
+}
+
+#[test]
+fn test_transfer_ownership() {
+    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);
+
+    assert_eq!(contract_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: &[],
+        },
+    }]);
+    contract_client.transfer_ownership(&new_owner);
+
+    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+
+    // assert owner
+    assert_eq!(contract_client.owner(), Some(new_owner.clone()));
+}
+
+#[test]
+fn test_call_no_owner_set() {
+    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();
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "require_owner_auth",
+            sub_invokes: &[],
+        },
+    }]);
+    let result = contract_client.try_require_owner_auth();
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
+}
+
+#[test]
+fn test_set_owner_when_already_set() {
+    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 result = contract_client.try_init_owner(&new_owner);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OwnableError::OwnerAlreadySet.into());
+}