@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,1006 @@
+use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, Bytes, BytesN, Env};
+
+use crate::buffer_reader::BufferReader;
+use crate::buffer_writer::BufferWriter;
+
+#[test]
+fn test_new_buffer_reader() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0u8, 1, 2, 3, 4, 5]);
+    let _reader = BufferReader::new(&bytes);
+
+    // Verify reader is created (we can't access pos directly but can verify by reading)
+    assert!(true); // Successfully created
+}
+
+#[test]
+fn test_read_u32() {
+    let env = Env::default();
+    // Create bytes representing u32 value 0x01020304 (16909060 in decimal)
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u32();
+    assert_eq!(value, 0x01020304u32);
+}
+
+#[test]
+fn test_read_u32_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00, 0x00, 0x00, 0x00]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u32();
+    assert_eq!(value, 0u32);
+}
+
+#[test]
+fn test_read_u32_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF, 0xFF, 0xFF, 0xFF]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u32();
+    assert_eq!(value, u32::MAX);
+}
+
+#[test]
+fn test_read_u64() {
+    let env = Env::default();
+    // Create bytes representing u64 value 0x0102030405060708
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u64();
+    assert_eq!(value, 0x0102030405060708u64);
+}
+
+#[test]
+fn test_read_u64_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u64();
+    assert_eq!(value, 0u64);
+}
+
+#[test]
+fn test_read_u64_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u64();
+    assert_eq!(value, u64::MAX);
+}
+
+#[test]
+fn test_sequential_reads() {
+    let env = Env::default();
+
+    // Create a buffer with multiple values:
+    // - u32: 0x01020304
+    // - u64: 0x0102030405060708
+    // - another u32: 0xAABBCCDD
+    let buffer_array: [u8; 16] = [
+        0x01, 0x02, 0x03, 0x04, // u32
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // u64
+        0xAA, 0xBB, 0xCC, 0xDD, // u32
+    ];
+
+    let bytes = Bytes::from_array(&env, &buffer_array);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Read in sequence and verify position is being tracked correctly
+    let val1 = reader.read_u32();
+    assert_eq!(val1, 0x01020304u32);
+
+    let val2 = reader.read_u64();
+    assert_eq!(val2, 0x0102030405060708u64);
+
+    let val3 = reader.read_u32();
+    assert_eq!(val3, 0xAABBCCDDu32);
+}
+
+#[test]
+fn test_read_multiple_u32() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0x00, 0x00, 0x00, 0x01, // 1
+            0x00, 0x00, 0x00, 0x02, // 2
+            0x00, 0x00, 0x00, 0x03, // 3
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_u32(), 1u32);
+    assert_eq!(reader.read_u32(), 2u32);
+    assert_eq!(reader.read_u32(), 3u32);
+}
+
+#[test]
+fn test_read_multiple_u64() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // 1
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // 2
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_u64(), 1u64);
+    assert_eq!(reader.read_u64(), 2u64);
+}
+
+#[test]
+#[should_panic]
+fn test_read_u32_insufficient_bytes_empty() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - no bytes available
+    reader.read_u32();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u32_insufficient_bytes_partial() {
+    let env = Env::default();
+    // Only 3 bytes, need 4 for u32
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - not enough bytes
+    reader.read_u32();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u32_insufficient_bytes_one() {
+    let env = Env::default();
+    // Only 1 byte, need 4 for u32
+    let bytes = Bytes::from_array(&env, &[0x01]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - not enough bytes
+    reader.read_u32();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u64_insufficient_bytes_empty() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - no bytes available
+    reader.read_u64();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u64_insufficient_bytes_partial() {
+    let env = Env::default();
+    // Only 7 bytes, need 8 for u64
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - not enough bytes
+    reader.read_u64();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u64_insufficient_bytes_only_four() {
+    let env = Env::default();
+    // Only 4 bytes, need 8 for u64
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - not enough bytes
+    reader.read_u64();
+}
+
+#[test]
+#[should_panic]
+fn test_sequential_reads_run_out_of_bytes() {
+    let env = Env::default();
+
+    // Only enough for u32 and partial u64
+    let buffer_array: [u8; 10] = [
+        0x01, 0x02, 0x03, 0x04, // u32 (4 bytes)
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // partial u64 (only 6 bytes, need 8)
+    ];
+
+    let bytes = Bytes::from_array(&env, &buffer_array);
+    let mut reader = BufferReader::new(&bytes);
+
+    // First read succeeds
+    let _val1 = reader.read_u32();
+
+    // Second read should panic - not enough bytes for u64
+    reader.read_u64();
+}
+
+#[test]
+#[should_panic]
+fn test_read_after_buffer_exhausted() {
+    let env = Env::default();
+    // Exactly 4 bytes
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // First read succeeds and exhausts the buffer
+    let _val = reader.read_u32();
+
+    // Second read should panic - no bytes left
+    reader.read_u32();
+}
+
+// Tests for read() method
+#[test]
+fn test_read() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let chunk1 = reader.read_bytes(3);
+    assert_eq!(chunk1.len(), 3);
+    assert_eq!(chunk1.get(0).unwrap(), 0x01);
+    assert_eq!(chunk1.get(1).unwrap(), 0x02);
+    assert_eq!(chunk1.get(2).unwrap(), 0x03);
+
+    let chunk2 = reader.read_bytes(2);
+    assert_eq!(chunk2.len(), 2);
+    assert_eq!(chunk2.get(0).unwrap(), 0x04);
+    assert_eq!(chunk2.get(1).unwrap(), 0x05);
+}
+
+#[test]
+fn test_read_single_byte() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xAB]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let chunk = reader.read_bytes(1);
+    assert_eq!(chunk.len(), 1);
+    assert_eq!(chunk.get(0).unwrap(), 0xAB);
+}
+
+#[test]
+fn test_read_entire_buffer() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let chunk = reader.read_bytes(4);
+    assert_eq!(chunk.len(), 4);
+    assert_eq!(chunk.get(0).unwrap(), 0x01);
+    assert_eq!(chunk.get(3).unwrap(), 0x04);
+}
+
+// Tests for rewind() method
+#[test]
+fn test_rewind() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Read 4 bytes
+    let _chunk1 = reader.read_bytes(4);
+
+    // Rewind 2 bytes
+    reader.rewind(2);
+
+    // Read again should get bytes starting from position 2
+    let chunk2 = reader.read_bytes(2);
+    assert_eq!(chunk2.get(0).unwrap(), 0x03);
+    assert_eq!(chunk2.get(1).unwrap(), 0x04);
+}
+
+#[test]
+fn test_rewind_chaining() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(4);
+    // Test that rewind returns &mut Self for chaining
+    let chunk = reader.rewind(2).read_bytes(1);
+    assert_eq!(chunk.get(0).unwrap(), 0x03);
+}
+
+#[test]
+fn test_rewind_to_start() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xAA, 0xBB, 0xCC]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(3);
+    reader.rewind(3);
+
+    let chunk = reader.read_bytes(1);
+    assert_eq!(chunk.get(0).unwrap(), 0xAA);
+}
+
+// Tests for read_u8() method
+#[test]
+fn test_read_u8() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x42]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u8();
+    assert_eq!(value, 0x42);
+}
+
+#[test]
+fn test_read_u8_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u8();
+    assert_eq!(value, 0u8);
+}
+
+#[test]
+fn test_read_u8_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u8();
+    assert_eq!(value, u8::MAX);
+}
+
+#[test]
+fn test_read_multiple_u8() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_u8(), 0x01);
+    assert_eq!(reader.read_u8(), 0x02);
+    assert_eq!(reader.read_u8(), 0x03);
+    assert_eq!(reader.read_u8(), 0x04);
+}
+
+#[test]
+#[should_panic]
+fn test_read_u8_insufficient_bytes() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_u8();
+}
+
+// Tests for read_u16() method
+#[test]
+fn test_read_u16() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x12, 0x34]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u16();
+    assert_eq!(value, 0x1234u16);
+}
+
+#[test]
+fn test_read_u16_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00, 0x00]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u16();
+    assert_eq!(value, 0u16);
+}
+
+#[test]
+fn test_read_u16_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF, 0xFF]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u16();
+    assert_eq!(value, u16::MAX);
+}
+
+#[test]
+fn test_read_multiple_u16() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00, 0x01, 0x00, 0x02, 0x00, 0x03]);
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.read_u16(), 1u16);
+    assert_eq!(reader.read_u16(), 2u16);
+    assert_eq!(reader.read_u16(), 3u16);
+}
+
+#[test]
+#[should_panic]
+fn test_read_u16_insufficient_bytes_empty() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_u16();
+}
+
+#[test]
+#[should_panic]
+fn test_read_u16_insufficient_bytes_one() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_u16();
+}
+
+// Tests for read_u256() method
+#[test]
+fn test_read_u256() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u256();
+    let expected = soroban_sdk::U256::from_u32(&env, 0x01020304);
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_read_u256_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u256();
+    let expected = soroban_sdk::U256::from_u32(&env, 0);
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_read_u256_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u256();
+    // Verify it's a large number by checking it's not zero
+    assert!(value > soroban_sdk::U256::from_u32(&env, 0));
+}
+
+#[test]
+#[should_panic]
+fn test_read_u256_insufficient_bytes() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]); // Only 4 bytes, need 32
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_u256();
+}
+
+// Tests for read_bytes_until_end() method
+#[test]
+fn test_read_bytes_until_end() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(2); // Read first 2 bytes
+
+    let remaining = reader.read_bytes_until_end();
+    assert_eq!(remaining.len(), 4);
+    assert_eq!(remaining.get(0).unwrap(), 0x03);
+    assert_eq!(remaining.get(1).unwrap(), 0x04);
+    assert_eq!(remaining.get(2).unwrap(), 0x05);
+    assert_eq!(remaining.get(3).unwrap(), 0x06);
+}
+
+#[test]
+fn test_read_bytes_until_end_entire_buffer() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xAA, 0xBB, 0xCC]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let remaining = reader.read_bytes_until_end();
+    assert_eq!(remaining.len(), 3);
+    assert_eq!(remaining.get(0).unwrap(), 0xAA);
+    assert_eq!(remaining.get(1).unwrap(), 0xBB);
+    assert_eq!(remaining.get(2).unwrap(), 0xCC);
+}
+
+#[test]
+fn test_read_bytes_until_end_empty() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(2); // Exhaust the buffer
+
+    let remaining = reader.read_bytes_until_end();
+    assert_eq!(remaining.len(), 0);
+}
+
+#[test]
+fn test_read_bytes_until_end_updates_position() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(1);
+    let _remaining = reader.read_bytes_until_end();
+
+    // After read_bytes_until_end, position should be at the end
+    assert_eq!(reader.remaining(), 0);
+}
+
+// Tests for len() method
+#[test]
+fn test_len() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05]);
+    let reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.len(), 5);
+}
+
+#[test]
+fn test_len_empty_buffer() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.len(), 0);
+}
+
+#[test]
+fn test_len_unchanged_after_read() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.len(), 4);
+    reader.read_bytes(2);
+    assert_eq!(reader.len(), 4); // len() should not change
+}
+
+// Tests for remaining() method
+#[test]
+fn test_remaining_initial() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05]);
+    let reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.remaining(), 5);
+}
+
+#[test]
+fn test_remaining_after_read() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(2);
+    assert_eq!(reader.remaining(), 4);
+
+    reader.read_bytes(3);
+    assert_eq!(reader.remaining(), 1);
+
+    reader.read_bytes(1);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_remaining_empty_buffer() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let reader = BufferReader::new(&bytes);
+
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_remaining_after_rewind() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    reader.read_bytes(3);
+    assert_eq!(reader.remaining(), 1);
+
+    reader.rewind(2);
+    assert_eq!(reader.remaining(), 3);
+}
+
+#[test]
+fn test_read_u128() {
+    let env = Env::default();
+    // Create bytes representing u128 value 0x0102030405060708090a0b0c0d0e0f10
+    let bytes = Bytes::from_array(
+        &env,
+        &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u128();
+    assert_eq!(value, 0x0102030405060708090a0b0c0d0e0f10u128);
+}
+
+#[test]
+fn test_read_u128_zero() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00; 16]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u128();
+    assert_eq!(value, 0u128);
+}
+
+#[test]
+fn test_read_u128_max_value() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF; 16]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u128();
+    assert_eq!(value, u128::MAX);
+}
+
+#[test]
+fn test_read_u128_specific_value() {
+    let env = Env::default();
+    // Test with a specific value: 200000 (0x030d40)
+    let mut bytes_array = [0u8; 16];
+    // Fill with zeros except for the last 3 bytes
+    bytes_array[13] = 0x03;
+    bytes_array[14] = 0x0d;
+    bytes_array[15] = 0x40;
+    let bytes = Bytes::from_array(&env, &bytes_array);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_u128();
+    assert_eq!(value, 200000u128);
+}
+
+#[test]
+fn test_read_bytes_n() {
+    let env = Env::default();
+    // Create 32 bytes with a pattern
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            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 mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_bytes_n::<32>();
+    let expected = BytesN::<32>::from_array(
+        &env,
+        &[
+            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,
+        ],
+    );
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_read_bytes_n_zeros() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x00; 32]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_bytes_n::<32>();
+    let expected = BytesN::<32>::from_array(&env, &[0x00; 32]);
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_read_bytes_n_all_ones() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0xFF; 32]);
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_bytes_n::<32>();
+    let expected = BytesN::<32>::from_array(&env, &[0xFF; 32]);
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_read_bytes_n_different_sizes() {
+    let env = Env::default();
+    // Create buffer with 4 + 8 + 16 = 28 bytes
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0x01, 0x02, 0x03, 0x04, // 4 bytes
+            0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, // 8 bytes
+            0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
+            0x1c, // 16 bytes
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let val4: BytesN<4> = reader.read_bytes_n();
+    assert_eq!(val4, BytesN::<4>::from_array(&env, &[0x01, 0x02, 0x03, 0x04]));
+
+    let val8: BytesN<8> = reader.read_bytes_n();
+    assert_eq!(val8, BytesN::<8>::from_array(&env, &[0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c]));
+
+    let val16: BytesN<16> = reader.read_bytes_n();
+    assert_eq!(
+        val16,
+        BytesN::<16>::from_array(
+            &env,
+            &[0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c]
+        )
+    );
+
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_read_bytes_n_address_pattern() {
+    let env = Env::default();
+    // Test with a typical Ethereum-style address padded to 32 bytes
+    let bytes = Bytes::from_array(
+        &env,
+        &[
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xf3, 0x9f, 0xd6, 0xe5, 0x1a, 0xad, 0x88, 0xf6, 0xf4, 0xce, 0x6a, 0xb8,
+            0x82, 0x72, 0x79, 0xcf, 0xff, 0xb9, 0x22, 0x66,
+        ],
+    );
+    let mut reader = BufferReader::new(&bytes);
+
+    let value = reader.read_bytes_n::<32>();
+    let expected = BytesN::<32>::from_array(
+        &env,
+        &[
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xf3, 0x9f, 0xd6, 0xe5, 0x1a, 0xad, 0x88, 0xf6, 0xf4, 0xce, 0x6a, 0xb8,
+            0x82, 0x72, 0x79, 0xcf, 0xff, 0xb9, 0x22, 0x66,
+        ],
+    );
+    assert_eq!(value, expected);
+}
+
+#[test]
+fn test_sequential_reads_with_u128_and_bytes32() {
+    let env = Env::default();
+
+    // Create a buffer with:
+    // - u8: 0x01
+    // - u16: 0x0011
+    // - u128: 200000
+    // - bytes32: all 0x42s
+    let mut final_bytes = Bytes::new(&env);
+
+    // u8
+    final_bytes.push_back(0x01);
+
+    // u16
+    final_bytes.extend_from_slice(&[0x00, 0x11]);
+
+    // u128 (200000)
+    final_bytes.extend_from_slice(&200000u128.to_be_bytes());
+
+    // bytes32
+    final_bytes.extend_from_slice(&[0x42; 32]);
+
+    let mut reader = BufferReader::new(&final_bytes);
+
+    // Read in sequence
+    let val1 = reader.read_u8();
+    assert_eq!(val1, 0x01);
+
+    let val2 = reader.read_u16();
+    assert_eq!(val2, 0x0011);
+
+    let val3 = reader.read_u128();
+    assert_eq!(val3, 200000u128);
+
+    let val4 = reader.read_bytes_n::<32>();
+    let expected = BytesN::<32>::from_array(&env, &[0x42; 32]);
+    assert_eq!(val4, expected);
+
+    // Should have read everything
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_read_arbitrary_size() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Read 4 bytes
+    let chunk1 = reader.read_bytes(4);
+    assert_eq!(chunk1.len(), 4);
+    assert_eq!(chunk1.get(0).unwrap(), 0x01);
+    assert_eq!(chunk1.get(3).unwrap(), 0x04);
+
+    // Read remaining 4 bytes
+    let chunk2 = reader.read_bytes(4);
+    assert_eq!(chunk2.len(), 4);
+    assert_eq!(chunk2.get(0).unwrap(), 0x05);
+    assert_eq!(chunk2.get(3).unwrap(), 0x08);
+
+    // All bytes consumed
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+#[should_panic]
+fn test_read_insufficient_bytes() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Try to read more bytes than available
+    // Should panic with InsufficientBytes error
+    reader.read_bytes(10);
+}
+
+#[test]
+#[should_panic]
+fn test_read_insufficient_bytes_after_partial_read() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[0x01, 0x02, 0x03, 0x04]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Read 2 bytes successfully
+    let _chunk = reader.read_bytes(2);
+    assert_eq!(reader.remaining(), 2);
+
+    // Try to read 3 bytes when only 2 remain
+    // Should panic with InsufficientBytes error
+    reader.read_bytes(3);
+}
+
+// Tests for read_address() method
+#[test]
+fn test_read_address_contract_roundtrip() {
+    let env = Env::default();
+
+    // Address::generate() creates a Contract address
+    let original_address = Address::generate(&env);
+    let payload = original_address.to_payload().unwrap();
+    assert!(matches!(payload, AddressPayload::ContractIdHash(_)));
+
+    // Serialize using BufferWriter, then read back
+    let mut writer = BufferWriter::new(&env);
+    writer.write_address(&original_address);
+    let bytes = writer.to_bytes();
+
+    let mut reader = BufferReader::new(&bytes);
+    let read_address = reader.read_address();
+
+    assert_eq!(read_address, original_address);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_read_address_account_roundtrip() {
+    let env = Env::default();
+
+    // Create an account address from a 32-byte payload
+    let account_payload = BytesN::<32>::from_array(
+        &env,
+        &[
+            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_address = Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(account_payload));
+    let payload = original_address.to_payload().unwrap();
+    assert!(matches!(payload, AddressPayload::AccountIdPublicKeyEd25519(_)));
+
+    // Serialize using BufferWriter, then read back
+    let mut writer = BufferWriter::new(&env);
+    writer.write_address(&original_address);
+    let bytes = writer.to_bytes();
+
+    let mut reader = BufferReader::new(&bytes);
+    let read_address = reader.read_address();
+
+    assert_eq!(read_address, original_address);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_read_address_mixed_types_roundtrip() {
+    let env = Env::default();
+
+    // Generate contract address
+    let contract_addr = Address::generate(&env);
+
+    // Create account address
+    let account_payload = BytesN::<32>::from_array(&env, &[0x42; 32]);
+    let account_addr = Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(account_payload));
+
+    // Serialize both addresses (33 * 2 = 66 bytes)
+    let mut writer = BufferWriter::new(&env);
+    writer.write_address(&contract_addr);
+    writer.write_address(&account_addr);
+    let bytes = writer.to_bytes();
+
+    assert_eq!(bytes.len(), 66); // 33 bytes per address
+
+    let mut reader = BufferReader::new(&bytes);
+    assert_eq!(reader.read_address(), contract_addr);
+    assert_eq!(reader.read_address(), account_addr);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_read_address_with_other_data_roundtrip() {
+    let env = Env::default();
+
+    let original_address = Address::generate(&env);
+
+    // Create buffer: u32 + address (33 bytes) + u64
+    let mut writer = BufferWriter::new(&env);
+    writer.write_u32(0x12345678);
+    writer.write_address(&original_address);
+    writer.write_u64(0xAABBCCDDEEFF0011);
+    let bytes = writer.to_bytes();
+
+    assert_eq!(bytes.len(), 4 + 33 + 8);
+
+    let mut reader = BufferReader::new(&bytes);
+    assert_eq!(reader.read_u32(), 0x12345678);
+    assert_eq!(reader.read_address(), original_address);
+    assert_eq!(reader.read_u64(), 0xAABBCCDDEEFF0011);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+#[should_panic]
+fn test_read_address_insufficient_bytes_empty() {
+    let env = Env::default();
+    let bytes = Bytes::from_array(&env, &[]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - no bytes available (need 33)
+    reader.read_address();
+}
+
+#[test]
+#[should_panic]
+fn test_read_address_insufficient_bytes_partial() {
+    let env = Env::default();
+    // Only 32 bytes, need 33
+    let bytes = Bytes::from_array(&env, &[0x00; 32]);
+    let mut reader = BufferReader::new(&bytes);
+
+    // Should panic - not enough bytes
+    reader.read_address();
+}