tempo_precompiles/storage/types/

bytes_like.rs

//! Bytes-like (`Bytes`, `String`) implementation for the storage traits.
//!
//! # Storage Layout
//!
//! Bytes-like types use Solidity-compatible:
//! **Short strings (≤31 bytes)** are stored inline in a single slot:
//! - Bytes 0..len: UTF-8 string data (left-aligned)
//! - Byte 31 (LSB): length * 2 (bit 0 = 0 indicates short string)
//!
//! **Long strings (≥32 bytes)** use keccak256-based storage:
//! - Base slot: stores `length * 2 + 1` (bit 0 = 1 indicates long string)
//! - Data slots: stored at `keccak256(main_slot) + i` for each 32-byte chunk

use crate::{
    error::{Result, TempoPrecompileError},
    storage::{StorageCtx, StorageOps, types::*},
};
use alloy::primitives::{Address, Bytes, U256, keccak256};
use std::marker::PhantomData;

impl StorableType for Bytes {
    const LAYOUT: Layout = Layout::Slots(1);
    const IS_DYNAMIC: bool = true;
    type Handler = BytesLikeHandler<Self>;

    fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler {
        BytesLikeHandler::new(slot, address)
    }
}

impl StorableType for String {
    const LAYOUT: Layout = Layout::Slots(1);
    const IS_DYNAMIC: bool = true;
    type Handler = BytesLikeHandler<Self>;

    fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler {
        BytesLikeHandler::new(slot, address)
    }
}

// -- BYTES-LIKE HANDLER -------------------------------------------------------

/// Handler for bytes-like types (`Bytes`, `String`) that provides efficient length queries.
#[derive(Debug, Clone)]
pub struct BytesLikeHandler<T> {
    base_slot: U256,
    address: Address,
    _ty: PhantomData<T>,
}

impl<T: Storable> BytesLikeHandler<T> {
    /// Creates a new handler for the bytes-like value at the given base slot.
    #[inline]
    pub fn new(base_slot: U256, address: Address) -> Self {
        Self {
            base_slot,
            address,
            _ty: PhantomData,
        }
    }

    #[inline]
    fn as_slot(&self) -> Slot<T> {
        Slot::new(self.base_slot, self.address)
    }

    /// Returns the byte length without loading all data (only reads base slot).
    #[inline]
    pub fn len(&self) -> Result<usize> {
        let base_value = Slot::<U256>::new(self.base_slot, self.address).read()?;
        let is_long = is_long_string(base_value);
        calc_string_length(base_value, is_long)
    }

    /// Returns whether the stored value is empty.
    #[inline]
    pub fn is_empty(&self) -> Result<bool> {
        Ok(self.len()? == 0)
    }
}

impl<T: Storable> Handler<T> for BytesLikeHandler<T> {
    #[inline]
    fn read(&self) -> Result<T> {
        self.as_slot().read()
    }

    #[inline]
    fn write(&mut self, value: T) -> Result<()> {
        self.as_slot().write(value)
    }

    #[inline]
    fn delete(&mut self) -> Result<()> {
        self.as_slot().delete()
    }

    #[inline]
    fn t_read(&self) -> Result<T> {
        self.as_slot().t_read()
    }

    #[inline]
    fn t_write(&mut self, value: T) -> Result<()> {
        self.as_slot().t_write(value)
    }

    #[inline]
    fn t_delete(&mut self) -> Result<()> {
        self.as_slot().t_delete()
    }
}

// -- STORABLE OPS IMPLEMENTATIONS ---------------------------------------------

impl Storable for Bytes {
    #[inline]
    fn load<S: StorageOps>(storage: &S, slot: U256, ctx: LayoutCtx) -> Result<Self> {
        debug_assert!(ctx.is_full(), "Bytes cannot be packed");
        load_bytes_like(storage, slot, |data| Ok(Self::from(data)))
    }

    #[inline]
    fn store<S: StorageOps>(&self, storage: &mut S, slot: U256, ctx: LayoutCtx) -> Result<()> {
        debug_assert!(ctx.is_full(), "Bytes cannot be packed");
        store_bytes_like(self.as_ref(), storage, slot, ctx)
    }

    /// Custom delete for bytes-like types: clears keccak256-addressed data slots for long values.
    #[inline]
    fn delete<S: StorageOps>(storage: &mut S, slot: U256, ctx: LayoutCtx) -> Result<()> {
        debug_assert!(ctx.is_full(), "Bytes cannot be packed");
        delete_bytes_like(storage, slot)
    }
}

impl Storable for String {
    #[inline]
    fn load<S: StorageOps>(storage: &S, slot: U256, ctx: LayoutCtx) -> Result<Self> {
        debug_assert!(ctx.is_full(), "String cannot be packed");
        load_bytes_like(storage, slot, |data| {
            Self::from_utf8(data).map_err(|e| {
                TempoPrecompileError::Fatal(format!("Invalid UTF-8 in stored string: {e}"))
            })
        })
    }

    #[inline]
    fn store<S: StorageOps>(&self, storage: &mut S, slot: U256, ctx: LayoutCtx) -> Result<()> {
        debug_assert!(ctx.is_full(), "String cannot be packed");
        store_bytes_like(self.as_bytes(), storage, slot, ctx)
    }

    /// Custom delete for bytes-like types: clears keccak256-addressed data slots for long values.
    #[inline]
    fn delete<S: StorageOps>(storage: &mut S, slot: U256, ctx: LayoutCtx) -> Result<()> {
        debug_assert!(ctx.is_full(), "String cannot be packed");
        delete_bytes_like(storage, slot)
    }
}

// -- HELPER FUNCTIONS ---------------------------------------------------------

/// Generic load implementation for string-like types (String, Bytes) using Solidity's encoding.
#[inline]
fn load_bytes_like<T, S, F>(storage: &S, base_slot: U256, into: F) -> Result<T>
where
    S: StorageOps,
    F: FnOnce(Vec<u8>) -> Result<T>,
{
    let base_value = storage.load(base_slot)?;
    let is_long = is_long_string(base_value);
    let length = calc_string_length(base_value, is_long)?;

    if is_long {
        // Long string: read data from keccak256(base_slot) + i
        let slot_start = calc_data_slot(base_slot);
        let chunks = calc_chunks(length);
        let mut data = Vec::new();

        for i in 0..chunks {
            let slot = slot_start + U256::from(i);
            let chunk_value = storage.load(slot)?;
            let chunk_bytes = chunk_value.to_be_bytes::<32>();

            // For the last chunk, only take the remaining bytes
            let bytes_to_take = if i == chunks - 1 {
                length - (i * 32)
            } else {
                32
            };
            data.extend_from_slice(&chunk_bytes[..bytes_to_take]);
        }

        into(data)
    } else {
        // Short string: data is inline in the main slot
        let bytes = base_value.to_be_bytes::<32>();
        into(bytes[..length].to_vec())
    }
}

/// Generic store implementation for byte-like types (String, Bytes) using Solidity's encoding.
/// On T5+ performs tail cleanup when the prior value was long and the new one takes fewer slots.
#[inline]
fn store_bytes_like<S: StorageOps>(
    bytes: &[u8],
    storage: &mut S,
    base_slot: U256,
    ctx: LayoutCtx,
) -> Result<()> {
    let new_len = bytes.len();
    let new_is_long = new_len > 31;
    let mut data_slot: Option<U256> = None;

    // (T5+) Cleanup stale tail if necessary.
    if !ctx.skip_tail_cleanup() && StorageCtx.spec().is_t5() {
        let prev = storage.load(base_slot)?;
        // Only applicable to long strings, as short ones always get overridden.
        if is_long_string(prev) {
            let prev_chunks = calc_chunks(calc_string_length(prev, true)?);
            let new_chunks = if new_is_long { calc_chunks(new_len) } else { 0 };
            if prev_chunks > new_chunks {
                let slot_start = calc_data_slot(base_slot);
                for i in new_chunks..prev_chunks {
                    storage.store(slot_start + U256::from(i), U256::ZERO)?;
                }
                data_slot = Some(slot_start);
            }
        }
    }

    if !new_is_long {
        storage.store(base_slot, encode_short_string(bytes))
    } else {
        storage.store(base_slot, encode_long_string_length(new_len))?;

        // Store data in chunks at keccak256(base_slot) + i
        let slot_start = data_slot.unwrap_or_else(|| calc_data_slot(base_slot));
        let chunks = calc_chunks(new_len);
        for i in 0..chunks {
            let slot = slot_start + U256::from(i);
            let chunk_start = i * 32;
            let chunk_end = (chunk_start + 32).min(new_len);
            let chunk = &bytes[chunk_start..chunk_end];

            // Pad chunk to 32 bytes if it's the last chunk
            let mut chunk_bytes = [0u8; 32];
            chunk_bytes[..chunk.len()].copy_from_slice(chunk);

            storage.store(slot, U256::from_be_bytes(chunk_bytes))?;
        }

        Ok(())
    }
}

/// Generic delete implementation for byte-like types (String, Bytes) using Solidity's encoding.
///
/// Clears both the main slot and any keccak256-addressed data slots for long strings.
#[inline]
fn delete_bytes_like<S: StorageOps>(storage: &mut S, base_slot: U256) -> Result<()> {
    let base_value = storage.load(base_slot)?;
    let is_long = is_long_string(base_value);

    if is_long {
        // Long string: need to clear data slots as well
        let length = calc_string_length(base_value, true)?;
        let slot_start = calc_data_slot(base_slot);
        let chunks = calc_chunks(length);

        // Clear all data slots
        for i in 0..chunks {
            let slot = slot_start + U256::from(i);
            storage.store(slot, U256::ZERO)?;
        }
    }

    // Clear the main slot
    storage.store(base_slot, U256::ZERO)
}

/// Compute the storage slot where long string data begins.
///
/// For long strings (≥32 bytes), data is stored starting at `keccak256(base_slot)`.
#[inline]
fn calc_data_slot(base_slot: U256) -> U256 {
    U256::from_be_bytes(keccak256(base_slot.to_be_bytes::<32>()).0)
}

/// Check if a storage slot value represents a long string.
///
/// Solidity string encoding uses bit 0 of the LSB to distinguish:
/// - Bit 0 = 0: Short string (≤31 bytes)
/// - Bit 0 = 1: Long string (≥32 bytes)
#[inline]
fn is_long_string(slot_value: U256) -> bool {
    (slot_value.byte(0) & 1) != 0
}

/// Extract and validate the string length from a storage slot value.
///
/// Returns an error if the decoded length overflows `usize` or a short-string length exceeds 31.
#[inline]
fn calc_string_length(slot_value: U256, is_long: bool) -> Result<usize> {
    if is_long {
        // Long string: slot stores (length * 2 + 1)
        // Extract length: (value - 1) / 2
        let length_times_two_plus_one: U256 = slot_value;
        let length_times_two: U256 = length_times_two_plus_one - U256::ONE;
        let length_u256: U256 = length_times_two >> 1;
        if length_u256 > U256::from(u32::MAX) {
            return Err(TempoPrecompileError::under_overflow());
        }
        Ok(length_u256.to::<usize>())
    } else {
        // Short string: LSB stores (length * 2)
        // Extract length: LSB / 2
        let bytes = slot_value.to_be_bytes::<32>();
        let length = (bytes[31] / 2) as usize;
        if length > 31 {
            // Unreachable unless the state has been tampered
            return Err(TempoPrecompileError::Fatal(format!(
                "short string length {length} exceeds maximum of 31 bytes"
            )));
        }
        Ok(length)
    }
}

/// Compute the number of 32-byte chunks needed to store a byte string.
#[inline]
fn calc_chunks(byte_length: usize) -> usize {
    byte_length.div_ceil(32)
}

/// Encode a short string (≤31 bytes) into a U256 for inline storage.
///
/// Format: bytes left-aligned, LSB contains (length * 2)
#[inline]
fn encode_short_string(bytes: &[u8]) -> U256 {
    let mut storage_bytes = [0u8; 32];
    storage_bytes[..bytes.len()].copy_from_slice(bytes);
    storage_bytes[31] = (bytes.len() * 2) as u8;
    U256::from_be_bytes(storage_bytes)
}

/// Encode the length metadata for a long string (≥32 bytes).
///
/// Returns `length * 2 + 1` where bit 0 = 1 indicates long string storage.
#[inline]
fn encode_long_string_length(byte_length: usize) -> U256 {
    U256::from(byte_length * 2 + 1)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        storage::{Handler, StorageCtx},
        test_util::setup_storage,
    };
    use proptest::prelude::*;

    // Strategy for generating random U256 slot values that won't overflow
    fn arb_safe_slot() -> impl Strategy<Value = U256> {
        any::<[u64; 4]>().prop_map(|limbs| {
            // Ensure we don't overflow by limiting to a reasonable range
            U256::from_limbs(limbs) % (U256::MAX - U256::from(10000))
        })
    }

    // Strategy for short strings (0-31 bytes) - uses inline storage
    fn arb_short_string() -> impl Strategy<Value = String> {
        prop_oneof![
            // Empty string
            Just(String::new()),
            // ASCII strings (1-31 bytes)
            "[a-zA-Z0-9]{1,31}",
            // Unicode strings (up to 31 bytes)
            "[\u{0041}-\u{005A}\u{4E00}-\u{4E19}]{1,10}",
        ]
    }

    // Strategy for exactly 32-byte strings - boundary between inline and heap storage
    fn arb_32byte_string() -> impl Strategy<Value = String> {
        "[a-zA-Z0-9]{32}"
    }

    // Strategy for long strings (33-100 bytes) - uses heap storage
    fn arb_long_string() -> impl Strategy<Value = String> {
        prop_oneof![
            // ASCII strings (33-100 bytes)
            "[a-zA-Z0-9]{33,100}",
            // Unicode strings (>32 bytes)
            "[\u{0041}-\u{005A}\u{4E00}-\u{4E19}]{11,30}",
        ]
    }

    // Strategy for short byte arrays (0-31 bytes) - uses inline storage
    fn arb_short_bytes() -> impl Strategy<Value = Bytes> {
        prop::collection::vec(any::<u8>(), 0..=31).prop_map(Bytes::from)
    }

    // Strategy for exactly 32-byte arrays - boundary between inline and heap storage
    fn arb_32byte_bytes() -> impl Strategy<Value = Bytes> {
        prop::collection::vec(any::<u8>(), 32..=32).prop_map(Bytes::from)
    }

    // Strategy for long byte arrays (33-100 bytes) - uses heap storage
    fn arb_long_bytes() -> impl Strategy<Value = Bytes> {
        prop::collection::vec(any::<u8>(), 33..=100).prop_map(Bytes::from)
    }

    // -- UNIT TESTS FOR HELPER FUNCTIONS (NO STORAGE) ------------------------

    #[test]
    fn test_calc_data_slot_matches_manual_keccak() {
        let base_slot = U256::random();
        let data_slot = calc_data_slot(base_slot);

        // Manual computation
        let expected = U256::from_be_bytes(keccak256(base_slot.to_be_bytes::<32>()).0);

        assert_eq!(
            data_slot, expected,
            "calc_data_slot should match manual keccak256 computation"
        );
    }

    #[test]
    fn test_is_long_string_boundaries() {
        // Short string (31 bytes): length * 2 = 62 (0x3E), bit 0 = 0
        let short_31_bytes = encode_short_string(&[b'a'; 31]);
        assert!(
            !is_long_string(short_31_bytes),
            "31-byte string should be short"
        );

        // Long string (32 bytes): length * 2 + 1 = 65 (0x41), bit 0 = 1
        let long_32_bytes = encode_long_string_length(32);
        assert!(
            is_long_string(long_32_bytes),
            "32-byte string should be long"
        );

        // Edge case: empty string
        let empty = encode_short_string(&[]);
        assert!(!is_long_string(empty), "Empty string should be short");

        // Edge case: 1-byte string
        let one_byte = encode_short_string(b"x");
        assert!(!is_long_string(one_byte), "1-byte string should be short");
    }

    #[test]
    fn test_calc_string_length_short() {
        // Test short strings with various lengths
        for len in 0..=31 {
            let bytes = vec![b'a'; len];
            let encoded = encode_short_string(&bytes);
            let decoded_len = calc_string_length(encoded, false);
            assert_eq!(
                decoded_len,
                Ok(len),
                "Short string length mismatch for {len} bytes"
            );
        }
    }

    #[test]
    fn test_calc_string_length_long() {
        // Test long strings with various lengths
        for len in [32, 33, 63, 64, 65, 100, 1000, 10000] {
            let encoded = encode_long_string_length(len);
            let decoded_len = calc_string_length(encoded, true);
            assert_eq!(
                decoded_len,
                Ok(len),
                "Long string length mismatch for {len} bytes"
            );
        }
    }

    #[test]
    fn test_calc_chunks_boundaries() {
        assert_eq!(calc_chunks(0), 0, "0 bytes should require 0 chunks");
        assert_eq!(calc_chunks(1), 1, "1 byte should require 1 chunk");
        assert_eq!(calc_chunks(31), 1, "31 bytes should require 1 chunk");
        assert_eq!(calc_chunks(32), 1, "32 bytes should require 1 chunk");
        assert_eq!(calc_chunks(33), 2, "33 bytes should require 2 chunks");
        assert_eq!(calc_chunks(64), 2, "64 bytes should require 2 chunks");
        assert_eq!(calc_chunks(65), 3, "65 bytes should require 3 chunks");
        assert_eq!(calc_chunks(100), 4, "100 bytes should require 4 chunks");
    }

    #[test]
    fn test_encode_short_string_format() {
        let test_str = b"Hello";
        let encoded = encode_short_string(test_str);
        let bytes = encoded.to_be_bytes::<32>();

        // Verify data is left-aligned
        assert_eq!(&bytes[..5], test_str, "Data should be left-aligned");

        // Verify padding is zero
        assert_eq!(&bytes[5..31], &[0u8; 26], "Padding should be zero");

        // Verify LSB contains length * 2
        assert_eq!(
            bytes[31],
            (test_str.len() * 2) as u8,
            "LSB should be length * 2"
        );

        // Verify bit 0 is 0 (short string marker)
        assert_eq!(bytes[31] & 1, 0, "Bit 0 should be 0 for short strings");
    }

    #[test]
    fn test_encode_short_string_empty() {
        let encoded = encode_short_string(&[]);
        let bytes = encoded.to_be_bytes::<32>();

        // All bytes should be zero for empty string
        assert_eq!(bytes, [0u8; 32], "Empty string should encode to all zeros");
    }

    #[test]
    fn test_encode_long_string_length_formula() {
        for len in [32, 33, 100, 1000, 10000] {
            let encoded = encode_long_string_length(len);
            let expected = U256::from(len * 2 + 1);
            assert_eq!(
                encoded, expected,
                "Long string length encoding mismatch for {len} bytes"
            );

            // Verify bit 0 is 1 (long string marker)
            assert_eq!(encoded.byte(0) & 1, 1, "Bit 0 should be 1 for long strings");
        }
    }

    #[test]
    fn test_encode_decode_roundtrip() {
        // Short strings roundtrip
        for len in [0, 1, 15, 30, 31] {
            let bytes = vec![b'x'; len];
            let encoded = encode_short_string(&bytes);
            let decoded_len = calc_string_length(encoded, false);
            assert_eq!(
                decoded_len,
                Ok(len),
                "Short string roundtrip failed for {len} bytes"
            );
        }

        // Long strings roundtrip
        for len in [32, 33, 64, 100] {
            let encoded = encode_long_string_length(len);
            let decoded_len = calc_string_length(encoded, true);
            assert_eq!(
                decoded_len,
                Ok(len),
                "Long string roundtrip failed for {len} bytes"
            );
        }
    }

    // -- TAMPERED STATE TESTS --------------------------------------------------

    #[test]
    fn test_calc_string_length_tampered() {
        // -- long-string overflow -----------------------------------------------

        // PoC value: decoded length = 0x0004000000000000, exceeds u32::MAX
        let malicious_slot = U256::from(0x0008000000000001u64);
        assert!(is_long_string(malicious_slot));
        assert_eq!(
            calc_string_length(malicious_slot, true),
            Err(TempoPrecompileError::under_overflow())
        );

        // Boundary: u32::MAX is accepted
        let at_max = U256::from(u64::from(u32::MAX) * 2 + 1);
        assert_eq!(calc_string_length(at_max, true), Ok(u32::MAX as usize));

        // Boundary: u32::MAX + 1 is rejected
        let above_max = U256::from((u64::from(u32::MAX) + 1) * 2 + 1);
        assert_eq!(
            calc_string_length(above_max, true),
            Err(TempoPrecompileError::under_overflow())
        );

        // -- short-string tamper ------------------------------------------------

        // Valid boundary: 31 bytes → LSB = 62 (0x3E), must be accepted
        let max_short = U256::from(31u64 * 2);
        assert!(!is_long_string(max_short));
        assert_eq!(calc_string_length(max_short, false), Ok(31));

        // Tampered: LSB = 0xFE → decoded length = 127, must be rejected
        let malicious_short = U256::from(0xFEu64);
        assert!(!is_long_string(malicious_short));
        assert!(calc_string_length(malicious_short, false).is_err());

        // Boundary: 32 bytes → LSB = 64 (0x40), must be rejected
        let above_short = U256::from(32u64 * 2);
        assert!(calc_string_length(above_short, false).is_err());
    }

    // -- PROPERTY TESTS FOR STORAGE INTERACTION -------------------------------

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(500))]

        #[test]
        fn test_short_strings(s in arb_short_string(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                let mut slot = BytesLikeHandler::<String>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(s.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(&s, &loaded, "Short string roundtrip failed");

                // Verify delete works
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, String::new(), "Short string not empty after delete");

                Ok(())
            }).unwrap();
        }

        #[test]
        #[allow(clippy::redundant_clone)]
        fn test_32byte_strings(s in arb_32byte_string(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                // Verify 32-byte boundary string is stored correctly
                prop_assert_eq!(s.len(), 32, "Generated string should be exactly 32 bytes");

                let mut slot = BytesLikeHandler::<String>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(s.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(s.clone(), loaded, "32-byte string roundtrip failed");

                // Verify delete works
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, String::new(), "32-byte string not empty after delete");

                Ok(())
            }).unwrap();
        }

        #[test]
        fn test_long_strings(s in arb_long_string(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                let mut slot = BytesLikeHandler::<String>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(s.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(&s, &loaded, "Long string roundtrip failed for length: {}", s.len());

                // Calculate how many data slots were used
                let chunks = calc_chunks(s.len());

                // Verify delete works (clears both main slot and keccak256-addressed data)
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, String::new(), "Long string not empty after delete");

                // Verify all keccak256-addressed data slots are actually zero
                let data_slot_start = calc_data_slot(base_slot);
                for i in 0..chunks {
                    let slot = Slot::<U256>::new_at_offset(data_slot_start, i, address);
                    let value = slot.read().unwrap();
                    prop_assert_eq!(value, U256::ZERO, "Data slot not cleared after delete");
                }

                Ok(())
            }).unwrap();
        }

        #[test]
        fn test_short_bytes(b in arb_short_bytes(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                let mut slot = BytesLikeHandler::<Bytes>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(b.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(&b, &loaded, "Short bytes roundtrip failed for length: {}", b.len());

                // Verify delete works
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, Bytes::new(), "Short bytes not empty after delete");

                Ok(())
            }).unwrap();
        }

        #[test]
        fn test_32byte_bytes(b in arb_32byte_bytes(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                // Verify 32-byte boundary bytes is stored correctly
                prop_assert_eq!(b.len(), 32, "Generated bytes should be exactly 32 bytes");

                let mut slot = BytesLikeHandler::<Bytes>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(b.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(&b, &loaded, "32-byte bytes roundtrip failed");

                // Verify delete works
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, Bytes::new(), "32-byte bytes not empty after delete");

                Ok(())
            }).unwrap();
        }

        #[test]
        fn test_long_bytes(b in arb_long_bytes(), base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                let mut slot = BytesLikeHandler::<Bytes>::new(base_slot, address);

                // Verify store → load roundtrip
                slot.write(b.clone()).unwrap();
                let loaded = slot.read().unwrap();
                prop_assert_eq!(&b, &loaded, "Long bytes roundtrip failed for length: {}", b.len());

                // Calculate how many data slots were used
                let chunks = calc_chunks(b.len());

                // Verify delete works (clears both main slot and keccak256-addressed data)
                slot.delete().unwrap();
                let after_delete = slot.read().unwrap();
                prop_assert_eq!(after_delete, Bytes::new(), "Long bytes not empty after delete");

                // Verify all keccak256-addressed data slots are actually zero
                let data_slot_start = calc_data_slot(base_slot);
                for i in 0..chunks {
                    let slot = Slot::<U256>::new_at_offset(data_slot_start, i, address);
                    let value = slot.read().unwrap();
                    prop_assert_eq!(value, U256::ZERO, "Data slot not cleared after delete");
                }

                Ok(())
            }).unwrap();
        }

        #[test]
        fn test_string_len(s in prop_oneof![arb_short_string(), arb_long_string()], base_slot in arb_safe_slot()) {
            let (mut storage, address) = setup_storage();
            StorageCtx::enter(&mut storage, || {
                let mut slot = BytesLikeHandler::<String>::new(base_slot, address);

                // Verify empty handler returns 0
                prop_assert_eq!(slot.len().unwrap(), 0, "Empty string should have len 0");
                prop_assert!(slot.is_empty().unwrap(), "Empty string should be empty");

                // Write string and verify len matches
                slot.write(s.clone()).unwrap();
                prop_assert_eq!(slot.len().unwrap(), s.len(), "len() should match string byte length");
                prop_assert_eq!(slot.is_empty().unwrap(), s.is_empty(), "is_empty() should match");

                // After delete, len should be 0 again
                slot.delete().unwrap();
                prop_assert_eq!(slot.len().unwrap(), 0, "Deleted string should have len 0");

                Ok(())
            }).unwrap();
        }
    }
}