//!  [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930): Access List types

/// Re-export from `alloy_eips`.
#[doc(inline)]
pub use alloy_eips::eip2930::{AccessList, AccessListItem};

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Address, B256};
    use alloy_rlp::{RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper};
    use proptest::proptest;
    use reth_codecs::{main_codec, Compact};

    /// This type is kept for compatibility tests after the codec support was added to alloy-eips
    /// AccessList type natively
    #[main_codec(rlp)]
    #[derive(
        Clone, Debug, PartialEq, Eq, Hash, Default, RlpDecodableWrapper, RlpEncodableWrapper,
    )]
    struct RethAccessList(
        #[proptest(
            strategy = "proptest::collection::vec(proptest::arbitrary::any::<RethAccessListItem>(), 0..=20)"
        )]
        Vec<RethAccessListItem>,
    );

    impl PartialEq<AccessList> for RethAccessList {
        fn eq(&self, other: &AccessList) -> bool {
            self.0.iter().zip(other.iter()).all(|(a, b)| a == b)
        }
    }

    // This
    #[main_codec(rlp)]
    #[derive(Clone, Debug, PartialEq, Eq, Hash, Default, RlpDecodable, RlpEncodable)]
    #[serde(rename_all = "camelCase")]
    struct RethAccessListItem {
        /// Account address that would be loaded at the start of execution
        address: Address,
        /// The storage keys to be loaded at the start of execution.
        ///
        /// Each key is a 32-byte value representing a specific storage slot.
        #[proptest(
            strategy = "proptest::collection::vec(proptest::arbitrary::any::<B256>(), 0..=20)"
        )]
        storage_keys: Vec<B256>,
    }

    impl PartialEq<AccessListItem> for RethAccessListItem {
        fn eq(&self, other: &AccessListItem) -> bool {
            self.address == other.address && self.storage_keys == other.storage_keys
        }
    }

    proptest!(
        #[test]
        fn test_roundtrip_accesslist_compat(access_list: RethAccessList) {
            // Convert access_list to buffer and then create alloy_access_list from buffer and
            // compare
            let mut compacted_reth_access_list = Vec::<u8>::new();
            let len = access_list.clone().to_compact(&mut compacted_reth_access_list);

            // decode the compacted buffer to AccessList
            let alloy_access_list = AccessList::from_compact(&compacted_reth_access_list, len).0;
            assert_eq!(access_list, alloy_access_list);

            let mut compacted_alloy_access_list = Vec::<u8>::new();
            let alloy_len = alloy_access_list.to_compact(&mut compacted_alloy_access_list);
            assert_eq!(len, alloy_len);
            assert_eq!(compacted_reth_access_list, compacted_alloy_access_list);
        }
    );
}
