@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -0,0 +1,179 @@
+extern crate std;
+
+use crate::auth::{enforce_auth, require_auth, Auth};
+use crate::tests::test_helper::mock_auth;
+use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Env, Symbol};
+
+// ============================================
+// Test Contract for auth helpers
+// ============================================
+
+#[contract]
+pub struct AuthTestContract;
+
+fn authorizer_key(env: &Env) -> Symbol {
+    Symbol::new(env, "authorizer")
+}
+
+#[contractimpl]
+impl AuthTestContract {
+    pub fn __constructor(env: &Env, authorizer: &Address) {
+        env.storage().instance().set(&authorizer_key(env), authorizer);
+    }
+
+    /// Test-only helper to update the authorizer in instance storage.
+    ///
+    /// NOTE: This is intentionally *not* protected by auth, since it's only used in unit tests.
+    pub fn set_authorizer(env: &Env, authorizer: &Address) {
+        env.storage().instance().set(&authorizer_key(env), authorizer);
+    }
+
+    pub fn enforce_auth_for_test(env: &Env) -> Address {
+        enforce_auth::<Self>(env)
+    }
+
+    pub fn require_auth_for_test(env: &Env) {
+        require_auth::<Self>(env);
+    }
+}
+
+/// `Auth` implementation for the test contract - uses a stored address as the authorizer.
+impl Auth for AuthTestContract {
+    fn authorizer(env: &Env) -> Address {
+        env.storage().instance().get(&authorizer_key(env)).expect("authorizer must be set in tests")
+    }
+}
+
+// ============================================
+// enforce_auth
+// ============================================
+
+#[test]
+fn test_enforce_auth_returns_authorizer_on_success() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    mock_auth(&env, &contract_id, &authorizer, "enforce_auth_for_test", ());
+
+    let got = client.enforce_auth_for_test();
+    assert_eq!(got, authorizer);
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_enforce_auth_panics_without_auth() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // No `mock_auths` provided -> authorizer.require_auth() must fail.
+    client.enforce_auth_for_test();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_enforce_auth_panics_with_wrong_address_auth() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+    let wrong_address = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // Provide auth for the wrong address -> must still fail because authorizer is different.
+    mock_auth(&env, &contract_id, &wrong_address, "enforce_auth_for_test", ());
+    client.enforce_auth_for_test();
+}
+
+// ============================================
+// require_auth
+// ============================================
+
+#[test]
+fn test_require_auth_succeeds_when_authorizer_auths() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    mock_auth(&env, &contract_id, &authorizer, "require_auth_for_test", ());
+
+    client.require_auth_for_test();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_require_auth_panics_without_auth() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // No `mock_auths` provided -> authorizer.require_auth() must fail.
+    client.require_auth_for_test();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_require_auth_panics_with_wrong_address_auth() {
+    let env = Env::default();
+    let authorizer = Address::generate(&env);
+    let wrong_address = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // Provide auth for the wrong address -> must still fail because authorizer is different.
+    mock_auth(&env, &contract_id, &wrong_address, "require_auth_for_test", ());
+    client.require_auth_for_test();
+}
+
+// ============================================
+// behavior: authorizer changes
+// ============================================
+
+#[test]
+fn test_enforce_auth_uses_current_authorizer_after_change() {
+    let env = Env::default();
+    let old_authorizer = Address::generate(&env);
+    let new_authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&old_authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // Update authorizer to `new_authorizer`.
+    client.set_authorizer(&new_authorizer);
+
+    // New authorizer can call, and enforce_auth returns the current authorizer.
+    mock_auth(&env, &contract_id, &new_authorizer, "require_auth_for_test", ());
+    client.require_auth_for_test();
+
+    mock_auth(&env, &contract_id, &new_authorizer, "enforce_auth_for_test", ());
+    let got = client.enforce_auth_for_test();
+    assert_eq!(got, new_authorizer);
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_require_auth_fails_with_stale_auth_after_authorizer_change() {
+    let env = Env::default();
+    let old_authorizer = Address::generate(&env);
+    let new_authorizer = Address::generate(&env);
+
+    let contract_id = env.register(AuthTestContract, (&old_authorizer,));
+    let client = AuthTestContractClient::new(&env, &contract_id);
+
+    // Change to a new authorizer, but only provide auth for the old one.
+    client.set_authorizer(&new_authorizer);
+    mock_auth(&env, &contract_id, &old_authorizer, "require_auth_for_test", ());
+
+    // Must fail because current authorizer is now `new_authorizer`.
+    client.require_auth_for_test();
+}

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

@@ -41,7 +41,7 @@ fn test_address_roundtrip(env: &Env, address: &Address) {
 }
 
 // ============================================
-// read_primitives tests (u8, u16, u32, u64, u128, u256, bool)
+// read_primitives tests (u8, u16, u32, u64, u128, i128, u256, bool)
 // ============================================
 
 #[test]
@@ -90,6 +90,140 @@ fn test_read_primitives_roundtrip() {
     assert_eq!(reader.remaining_len(), 0);
 }
 
+#[test]
+fn test_read_i128_roundtrip() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+    writer.write_i128(0).write_i128(-42).write_i128(123_456_789).write_i128(i128::MIN).write_i128(i128::MAX);
+
+    let bytes = writer.to_bytes();
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_i128(), 0);
+    assert_eq!(reader.read_i128(), -42);
+    assert_eq!(reader.read_i128(), 123_456_789);
+    assert_eq!(reader.read_i128(), i128::MIN);
+    assert_eq!(reader.read_i128(), i128::MAX);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_read_i8_i16_i32_i64_i128_big_endian_golden_bytes() {
+    let env = Env::default();
+
+    // Layout:
+    // - i8:  -1, MIN, MAX                         (3 bytes)
+    // - i16: -1, MIN, MAX                         (6 bytes)
+    // - i32: -1, MIN, MAX                         (12 bytes)
+    // - i64: -1, MIN, MAX                         (24 bytes)
+    // - i128: -1, MIN, MAX                        (48 bytes)
+    // Total = 93 bytes
+    let mut raw = [0u8; 93];
+    let mut pos = 0usize;
+
+    raw[pos] = (-1i8) as u8;
+    pos += 1;
+    raw[pos] = i8::MIN as u8;
+    pos += 1;
+    raw[pos] = i8::MAX as u8;
+    pos += 1;
+
+    raw[pos..pos + 2].copy_from_slice(&(-1i16).to_be_bytes());
+    pos += 2;
+    raw[pos..pos + 2].copy_from_slice(&i16::MIN.to_be_bytes());
+    pos += 2;
+    raw[pos..pos + 2].copy_from_slice(&i16::MAX.to_be_bytes());
+    pos += 2;
+
+    raw[pos..pos + 4].copy_from_slice(&(-1i32).to_be_bytes());
+    pos += 4;
+    raw[pos..pos + 4].copy_from_slice(&i32::MIN.to_be_bytes());
+    pos += 4;
+    raw[pos..pos + 4].copy_from_slice(&i32::MAX.to_be_bytes());
+    pos += 4;
+
+    raw[pos..pos + 8].copy_from_slice(&(-1i64).to_be_bytes());
+    pos += 8;
+    raw[pos..pos + 8].copy_from_slice(&i64::MIN.to_be_bytes());
+    pos += 8;
+    raw[pos..pos + 8].copy_from_slice(&i64::MAX.to_be_bytes());
+    pos += 8;
+
+    raw[pos..pos + 16].copy_from_slice(&[0xFF; 16]); // -1
+    pos += 16;
+    raw[pos] = 0x80; // i128::MIN (0x80 followed by 15x 0x00)
+    pos += 16;
+    raw[pos..pos + 16].copy_from_slice(&i128::MAX.to_be_bytes());
+    pos += 16;
+
+    assert_eq!(pos, raw.len());
+
+    let bytes = Bytes::from_array(&env, &raw);
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_i8(), -1);
+    assert_eq!(reader.read_i8(), i8::MIN);
+    assert_eq!(reader.read_i8(), i8::MAX);
+    assert_eq!(reader.position(), 3);
+
+    assert_eq!(reader.read_i16(), -1);
+    assert_eq!(reader.read_i16(), i16::MIN);
+    assert_eq!(reader.read_i16(), i16::MAX);
+    assert_eq!(reader.position(), 3 + 6);
+
+    assert_eq!(reader.read_i32(), -1);
+    assert_eq!(reader.read_i32(), i32::MIN);
+    assert_eq!(reader.read_i32(), i32::MAX);
+    assert_eq!(reader.position(), 3 + 6 + 12);
+
+    assert_eq!(reader.read_i64(), -1);
+    assert_eq!(reader.read_i64(), i64::MIN);
+    assert_eq!(reader.read_i64(), i64::MAX);
+    assert_eq!(reader.position(), 45);
+
+    assert_eq!(reader.read_i128(), -1);
+    assert_eq!(reader.position(), 45 + 16);
+    assert_eq!(reader.read_i128(), i128::MIN);
+    assert_eq!(reader.position(), 45 + 16 + 16);
+    assert_eq!(reader.read_i128(), i128::MAX);
+    assert_eq!(reader.position(), 93);
+
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_read_i256_big_endian_golden_bytes() {
+    use soroban_sdk::I256;
+
+    let env = Env::default();
+
+    // Layout: -1, MIN, MAX, +1
+    let mut raw = [0u8; 32 * 4];
+    raw[0..32].copy_from_slice(&[0xFF; 32]); // -1
+    raw[32] = 0x80; // MIN (0x80 followed by 31x 0x00)
+    raw[64] = 0x7F; // MAX (0x7F followed by 31x 0xFF)
+    raw[65..96].copy_from_slice(&[0xFF; 31]);
+    raw[127] = 0x01; // +1
+
+    let bytes = Bytes::from_array(&env, &raw);
+    let mut reader = BufferReader::new(&bytes);
+
+    let expected_neg1 = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[0..32]));
+    let expected_min = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[32..64]));
+    let expected_max = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[64..96]));
+    let expected_one = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[96..128]));
+
+    assert_eq!(reader.read_i256(), expected_neg1);
+    assert_eq!(reader.position(), 32);
+    assert_eq!(reader.read_i256(), expected_min);
+    assert_eq!(reader.position(), 64);
+    assert_eq!(reader.read_i256(), expected_max);
+    assert_eq!(reader.position(), 96);
+    assert_eq!(reader.read_i256(), expected_one);
+    assert_eq!(reader.position(), 128);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
 #[test]
 fn test_read_boundary_values() {
     let env = Env::default();
@@ -216,6 +350,53 @@ fn test_read_bytes_n() {
     assert_eq!(reader.remaining_len(), 0);
 }
 
+#[test]
+fn test_read_array_roundtrip_and_position() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xAA, 0xBB, 0xCC, 0xDD, 0x10, 0x11]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let a4: [u8; 4] = reader.read_array();
+    assert_eq!(a4, [0xAA, 0xBB, 0xCC, 0xDD]);
+    assert_eq!(reader.position(), 4);
+    assert_eq!(reader.remaining_len(), 2);
+
+    let a2: [u8; 2] = reader.read_array();
+    assert_eq!(a2, [0x10, 0x11]);
+    assert_eq!(reader.position(), 6);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_read_array_write_array_roundtrip() {
+    let env = Env::default();
+
+    let a4: [u8; 4] = [0x01, 0x02, 0x03, 0x04];
+    let a1: [u8; 1] = [0xAA];
+    let a8: [u8; 8] = [0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17];
+
+    let mut writer = BufferWriter::new(&env);
+    writer.write_array(&a4).write_array(&a1).write_array(&a8);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), (a4.len() + a1.len() + a8.len()) as u32);
+
+    let mut reader = BufferReader::new(&bytes);
+    let got4: [u8; 4] = reader.read_array();
+    assert_eq!(got4, a4);
+    assert_eq!(reader.position(), 4);
+
+    let got1: [u8; 1] = reader.read_array();
+    assert_eq!(got1, a1);
+    assert_eq!(reader.position(), 5);
+
+    let got8: [u8; 8] = reader.read_array();
+    assert_eq!(got8, a8);
+    assert_eq!(reader.position(), 13);
+
+    assert_eq!(reader.remaining_len(), 0);
+}
+
 #[test]
 fn test_read_bytes_zero_length() {
     let env = Env::default();
@@ -701,6 +882,21 @@ fn test_buffer_reader_invalid_length_panics_table() {
     const EXPECTED: &str = "Error(Contract, #1000)";
 
     let cases: &[(&str, &[u8], ReaderStep)] = &[
+        ("read_array<4> from 3", &[0x01, 0x02, 0x03], |r: &mut BufferReader| {
+            let _val: [u8; 4] = r.read_array();
+        }),
+        ("read_i8 empty", &[], |r: &mut BufferReader| {
+            r.read_i8();
+        }),
+        ("read_i16 1 byte", &[0x01], |r: &mut BufferReader| {
+            r.read_i16();
+        }),
+        ("read_i32 3 bytes", &[0x01, 0x02, 0x03], |r: &mut BufferReader| {
+            r.read_i32();
+        }),
+        ("read_i64 7 bytes", &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07], |r: &mut BufferReader| {
+            r.read_i64();
+        }),
         ("read_u8 empty", &[], |r: &mut BufferReader| {
             r.read_u8();
         }),
@@ -716,9 +912,15 @@ fn test_buffer_reader_invalid_length_panics_table() {
         ("read_u128 15 bytes", &[0x01; 15], |r: &mut BufferReader| {
             r.read_u128();
         }),
+        ("read_i128 15 bytes", &[0x01; 15], |r: &mut BufferReader| {
+            r.read_i128();
+        }),
         ("read_u256 31 bytes", &[0x01; 31], |r: &mut BufferReader| {
             r.read_u256();
         }),
+        ("read_i256 31 bytes", &[0x01; 31], |r: &mut BufferReader| {
+            r.read_i256();
+        }),
         ("read_bytes(10) from 4", &[0x01, 0x02, 0x03, 0x04], |r: &mut BufferReader| {
             r.read_bytes(10);
         }),

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

@@ -1,10 +1,8 @@
 use crate::{
-    buffer_reader::BufferReader,
-    buffer_writer::BufferWriter,
-    bytes_ext::BytesExt,
+    buffer_reader::BufferReader, buffer_writer::BufferWriter, bytes_ext::BytesExt,
     tests::test_helper::assert_address_payload_matches,
 };
-use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, Bytes, BytesN, Env, U256};
+use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, Bytes, BytesN, Env, I256, U256};
 
 /// Helper to test U256 write/read roundtrip
 fn test_u256_roundtrip(env: &Env, value: &soroban_sdk::U256) {
@@ -95,7 +93,7 @@ fn test_from_bytes_empty() {
 }
 
 // ============================================
-// write_primitives tests (u8, u16, u32, u64, u128, u256, bool)
+// write_primitives tests (u8, u16, u32, u64, u128, i128, u256, bool)
 // ============================================
 
 #[test]
@@ -122,6 +120,179 @@ fn test_write_primitives_big_endian_golden_bytes() {
     assert_eq!(got, expected);
 }
 
+#[test]
+fn test_write_signed_integers_big_endian_golden_bytes() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer
+        .write_i8(-1)
+        .write_i8(i8::MIN)
+        .write_i8(i8::MAX)
+        .write_i16(-1)
+        .write_i16(i16::MIN)
+        .write_i16(i16::MAX)
+        .write_i32(-1)
+        .write_i32(i32::MIN)
+        .write_i32(i32::MAX)
+        .write_i64(-1)
+        .write_i64(i64::MIN)
+        .write_i64(i64::MAX)
+        .write_i128(-1)
+        .write_i128(i128::MIN)
+        .write_i128(i128::MAX);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 93);
+    let got: [u8; 93] = bytes.to_array();
+
+    // Layout:
+    // - i8:  -1, MIN, MAX                         (3 bytes)
+    // - i16: -1, MIN, MAX                         (6 bytes)
+    // - i32: -1, MIN, MAX                         (12 bytes)
+    // - i64: -1, MIN, MAX                         (24 bytes)
+    // - i128: -1, MIN, MAX                        (48 bytes)
+    // Total = 93 bytes
+    let mut expected = [0u8; 93];
+    let mut pos = 0usize;
+
+    expected[pos] = (-1i8) as u8;
+    pos += 1;
+    expected[pos] = i8::MIN as u8;
+    pos += 1;
+    expected[pos] = i8::MAX as u8;
+    pos += 1;
+
+    expected[pos..pos + 2].copy_from_slice(&(-1i16).to_be_bytes());
+    pos += 2;
+    expected[pos..pos + 2].copy_from_slice(&i16::MIN.to_be_bytes());
+    pos += 2;
+    expected[pos..pos + 2].copy_from_slice(&i16::MAX.to_be_bytes());
+    pos += 2;
+
+    expected[pos..pos + 4].copy_from_slice(&(-1i32).to_be_bytes());
+    pos += 4;
+    expected[pos..pos + 4].copy_from_slice(&i32::MIN.to_be_bytes());
+    pos += 4;
+    expected[pos..pos + 4].copy_from_slice(&i32::MAX.to_be_bytes());
+    pos += 4;
+
+    expected[pos..pos + 8].copy_from_slice(&(-1i64).to_be_bytes());
+    pos += 8;
+    expected[pos..pos + 8].copy_from_slice(&i64::MIN.to_be_bytes());
+    pos += 8;
+    expected[pos..pos + 8].copy_from_slice(&i64::MAX.to_be_bytes());
+    pos += 8;
+
+    expected[pos..pos + 16].copy_from_slice(&(-1i128).to_be_bytes());
+    pos += 16;
+    expected[pos..pos + 16].copy_from_slice(&i128::MIN.to_be_bytes());
+    pos += 16;
+    expected[pos..pos + 16].copy_from_slice(&i128::MAX.to_be_bytes());
+    pos += 16;
+
+    assert_eq!(pos, expected.len());
+    assert_eq!(got, expected);
+}
+
+#[test]
+fn test_write_signed_integers_roundtrip() {
+    let env = Env::default();
+    let mut writer = BufferWriter::new(&env);
+
+    writer
+        .write_i8(0)
+        .write_i8(-1)
+        .write_i8(i8::MIN)
+        .write_i8(i8::MAX)
+        .write_i16(0)
+        .write_i16(-42)
+        .write_i16(i16::MIN)
+        .write_i16(i16::MAX)
+        .write_i32(0)
+        .write_i32(-42)
+        .write_i32(i32::MIN)
+        .write_i32(i32::MAX)
+        .write_i64(0)
+        .write_i64(-42)
+        .write_i64(i64::MIN)
+        .write_i64(i64::MAX)
+        .write_i128(0)
+        .write_i128(-42)
+        .write_i128(123_456_789)
+        .write_i128(i128::MIN)
+        .write_i128(i128::MAX);
+
+    let bytes = writer.to_bytes();
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_i8(), 0);
+    assert_eq!(reader.read_i8(), -1);
+    assert_eq!(reader.read_i8(), i8::MIN);
+    assert_eq!(reader.read_i8(), i8::MAX);
+
+    assert_eq!(reader.read_i16(), 0);
+    assert_eq!(reader.read_i16(), -42);
+    assert_eq!(reader.read_i16(), i16::MIN);
+    assert_eq!(reader.read_i16(), i16::MAX);
+
+    assert_eq!(reader.read_i32(), 0);
+    assert_eq!(reader.read_i32(), -42);
+    assert_eq!(reader.read_i32(), i32::MIN);
+    assert_eq!(reader.read_i32(), i32::MAX);
+
+    assert_eq!(reader.read_i64(), 0);
+    assert_eq!(reader.read_i64(), -42);
+    assert_eq!(reader.read_i64(), i64::MIN);
+    assert_eq!(reader.read_i64(), i64::MAX);
+
+    assert_eq!(reader.read_i128(), 0);
+    assert_eq!(reader.read_i128(), -42);
+    assert_eq!(reader.read_i128(), 123_456_789);
+    assert_eq!(reader.read_i128(), i128::MIN);
+    assert_eq!(reader.read_i128(), i128::MAX);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_write_i256_big_endian_golden_bytes_and_roundtrip() {
+    let env = Env::default();
+
+    // Golden layouts: -1, MIN, MAX, +1
+    let mut raw = [0u8; 32 * 4];
+    raw[0..32].copy_from_slice(&[0xFF; 32]); // -1
+    raw[32] = 0x80; // MIN (0x80 followed by 31x 0x00)
+    raw[64] = 0x7F; // MAX (0x7F followed by 31x 0xFF)
+    raw[65..96].copy_from_slice(&[0xFF; 31]);
+    raw[127] = 0x01; // +1
+
+    let expected_neg1 = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[0..32]));
+    let expected_min = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[32..64]));
+    let expected_max = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[64..96]));
+    let expected_one = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[96..128]));
+
+    let mut writer = BufferWriter::new(&env);
+    writer.write_i256(expected_neg1).write_i256(expected_min).write_i256(expected_max).write_i256(expected_one);
+
+    let bytes = writer.to_bytes();
+    assert_eq!(bytes.len(), 128);
+    let got: [u8; 128] = bytes.to_array();
+    assert_eq!(got, raw);
+
+    // Roundtrip through BufferReader.
+    let mut reader = BufferReader::new(&bytes);
+    let roundtrip_neg1 = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[0..32]));
+    let roundtrip_min = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[32..64]));
+    let roundtrip_max = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[64..96]));
+    let roundtrip_one = I256::from_be_bytes(&env, &Bytes::from_slice(&env, &raw[96..128]));
+
+    assert_eq!(reader.read_i256(), roundtrip_neg1);
+    assert_eq!(reader.read_i256(), roundtrip_min);
+    assert_eq!(reader.read_i256(), roundtrip_max);
+    assert_eq!(reader.read_i256(), roundtrip_one);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
 #[test]
 fn test_write_primitives_roundtrip() {
     let env = Env::default();

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

@@ -1,3 +1,4 @@
+mod auth;
 mod buffer_reader;
 mod buffer_writer;
 mod bytes_ext;
@@ -7,4 +8,5 @@ mod ownable;
 mod test_helper;
 mod testing_utils;
 mod ttl_configurable;
+mod ttl_extendable;
 mod upgradeable;