@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/endpoint/utils.cairo

@@ -0,0 +1,129 @@
+//! Endpoint test utils
+
+use layerzero::common::constants::ZERO_ADDRESS;
+use layerzero::endpoint::interfaces::endpoint::{IEndpointDispatcher, IEndpointSafeDispatcher};
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20SafeDispatcher};
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use starknet::ContractAddress;
+use crate::e2e::utils::deploy_blocked_message_lib;
+use crate::mocks::messaging_composer::MockMessagingComposer::MockMessagingComposerHelpersDispatcher;
+
+const INITIAL_SUPPLY: u256 = 100_000_000;
+
+/// Mock ERC20 for testing
+pub(crate) struct ERC20Mock {
+    pub token: ContractAddress,
+    pub dispatcher: IERC20Dispatcher,
+    pub safe_dispatcher: IERC20SafeDispatcher,
+    pub initial_supply: u256,
+}
+
+/// Endpoint for testing
+pub(crate) struct EndpointMock {
+    pub endpoint: ContractAddress,
+    pub dispatcher: IEndpointDispatcher,
+    pub safe_dispatcher: IEndpointSafeDispatcher,
+    pub token: ContractAddress,
+    pub token_dispatcher: IERC20Dispatcher,
+    pub safe_token_dispatcher: IERC20SafeDispatcher,
+}
+
+/// Deploy a mock ERC20 token for testing
+pub(crate) fn deploy_mock_erc20(initial_supply: u256, owner: ContractAddress) -> ERC20Mock {
+    let contract = declare("MockERC20").unwrap().contract_class();
+    let calldata = array![initial_supply.low.into(), initial_supply.high.into(), owner.into()];
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+
+    ERC20Mock {
+        token: contract_address,
+        dispatcher: IERC20Dispatcher { contract_address },
+        safe_dispatcher: IERC20SafeDispatcher { contract_address },
+        initial_supply,
+    }
+}
+
+/// Deploy a mock endpoint with a mock ERC20 for testing
+pub(crate) fn deploy_mock_endpoint(owner: ContractAddress, eid: u32) -> EndpointMock {
+    let ERC20Mock {
+        token, dispatcher: token_dispatcher, safe_dispatcher: safe_token_dispatcher, ..,
+    } = deploy_mock_erc20(INITIAL_SUPPLY, owner);
+
+    let contract = declare("MockEndpoint").unwrap().contract_class();
+    let calldata = array![eid.into()];
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+
+    EndpointMock {
+        endpoint: contract_address,
+        dispatcher: IEndpointDispatcher { contract_address },
+        safe_dispatcher: IEndpointSafeDispatcher { contract_address },
+        token,
+        token_dispatcher,
+        safe_token_dispatcher,
+    }
+}
+
+/// Endpoint deployed for testing
+pub(crate) struct EndpointDeploy {
+    pub endpoint: ContractAddress,
+    pub dispatcher: IEndpointDispatcher,
+    pub safe_dispatcher: IEndpointSafeDispatcher,
+}
+
+/// Deploy an endpoint with mock ERC20 for testing
+pub(crate) fn deploy_endpoint(owner: ContractAddress, eid: u32) -> EndpointDeploy {
+    let ERC20Mock { token, .. } = deploy_mock_erc20(INITIAL_SUPPLY, owner);
+    let blocked_library = deploy_blocked_message_lib();
+    let contract = declare("Endpoint").unwrap().contract_class();
+
+    let calldata = array![owner.into(), eid.into(), token.into(), blocked_library.into()];
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+
+    EndpointDeploy {
+        endpoint: contract_address,
+        dispatcher: IEndpointDispatcher { contract_address },
+        safe_dispatcher: IEndpointSafeDispatcher { contract_address },
+    }
+}
+
+/// Messaging composer mock for testing
+pub(crate) struct MessagingComposerMock {
+    pub composer: ContractAddress,
+    pub dispatcher: MockMessagingComposerHelpersDispatcher,
+}
+
+/// Deploy a mock messaging composer for testing
+pub(crate) fn deploy_mock_messaging_composer(token: ContractAddress) -> MessagingComposerMock {
+    let contract = declare("MockMessagingComposer").unwrap().contract_class();
+    let calldata = array![token.into()];
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+
+    MessagingComposerMock {
+        composer: contract_address,
+        dispatcher: MockMessagingComposerHelpersDispatcher { contract_address },
+    }
+}
+
+/// Deploy a simple message lib for testing
+pub(crate) fn deploy_simple_message_lib(endpoint: ContractAddress) -> ContractAddress {
+    let contract = declare("SimpleMessageLib").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![endpoint.into()]).unwrap();
+    address
+}
+
+/// Deploy an ultra light node for testing
+pub(crate) fn deploy_ultra_light_node(
+    owner: ContractAddress, endpoint: ContractAddress,
+) -> ContractAddress {
+    let treasury = ZERO_ADDRESS;
+    let treasury_native_fee_cap = 0;
+
+    let contract = declare("UltraLightNode").unwrap().contract_class();
+    let mut calldata = array![];
+    owner.serialize(ref calldata);
+    treasury.serialize(ref calldata);
+    endpoint.serialize(ref calldata);
+    treasury_native_fee_cap.serialize(ref calldata);
+
+    let (address, _) = contract.deploy(@calldata).unwrap();
+    address
+}

package/layerzero/tests/fuzzable/blockchain_config.cairo

@@ -0,0 +1,89 @@
+//! Fuzzable blockchain config
+
+use layerzero::common::constants::ZERO_ADDRESS;
+use snforge_std::fuzzable::Fuzzable;
+use starknet::ContractAddress;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+use crate::fuzzable::keys::FuzzableKeyPair;
+use crate::workers::dvn::utils::KeyPair;
+
+#[derive(Debug, Drop)]
+pub struct BlockchainConfig {
+    pub native_token_supply: u256,
+    pub native_token_owner: ContractAddress,
+    pub lz_token_supply: u256,
+    pub lz_token_owner: ContractAddress,
+    pub endpoint_owner: ContractAddress,
+    pub eid: Eid,
+    pub message_lib_owner: ContractAddress,
+    pub treasury_owner: ContractAddress,
+    pub oapp_owner: ContractAddress,
+    pub oft_name: ByteArray,
+    pub oft_symbol: ByteArray,
+    pub price_feed_owner: ContractAddress,
+    pub executor_role_admin: ContractAddress,
+    pub executor_admin: ContractAddress,
+    pub executor_owner: ContractAddress,
+    pub dvn_vid: u32,
+    pub dvn_signers: Array<KeyPair>,
+    pub dvn_role_admin: ContractAddress,
+    pub dvn_admin: ContractAddress,
+    pub dvn_owner: ContractAddress,
+    pub user: ContractAddress,
+}
+
+/// Generate a random blockchain config
+pub(crate) impl FuzzableBlockchainConfig of Fuzzable<BlockchainConfig> {
+    fn generate() -> BlockchainConfig {
+        BlockchainConfig {
+            native_token_supply: Fuzzable::generate(),
+            native_token_owner: Fuzzable::generate(),
+            lz_token_supply: Fuzzable::generate(),
+            lz_token_owner: Fuzzable::generate(),
+            endpoint_owner: Fuzzable::generate(),
+            eid: Fuzzable::generate(),
+            message_lib_owner: Fuzzable::generate(),
+            treasury_owner: Fuzzable::generate(),
+            oapp_owner: Fuzzable::generate(),
+            oft_name: Fuzzable::generate(),
+            oft_symbol: Fuzzable::generate(),
+            price_feed_owner: Fuzzable::generate(),
+            executor_role_admin: Fuzzable::generate(),
+            executor_admin: Fuzzable::generate(),
+            executor_owner: Fuzzable::generate(),
+            dvn_vid: Fuzzable::generate(),
+            dvn_signers: array![Fuzzable::generate(), Fuzzable::generate()],
+            dvn_role_admin: Fuzzable::generate(),
+            dvn_admin: Fuzzable::generate(),
+            dvn_owner: Fuzzable::generate(),
+            user: Fuzzable::generate(),
+        }
+    }
+
+    fn blank() -> BlockchainConfig {
+        BlockchainConfig {
+            native_token_supply: Default::default(),
+            native_token_owner: ZERO_ADDRESS,
+            lz_token_supply: Default::default(),
+            lz_token_owner: ZERO_ADDRESS,
+            endpoint_owner: ZERO_ADDRESS,
+            eid: Default::default(),
+            message_lib_owner: ZERO_ADDRESS,
+            treasury_owner: ZERO_ADDRESS,
+            oapp_owner: ZERO_ADDRESS,
+            oft_name: Default::default(),
+            oft_symbol: Default::default(),
+            price_feed_owner: ZERO_ADDRESS,
+            executor_role_admin: ZERO_ADDRESS,
+            executor_admin: ZERO_ADDRESS,
+            executor_owner: ZERO_ADDRESS,
+            dvn_vid: Default::default(),
+            dvn_signers: Default::default(),
+            dvn_role_admin: ZERO_ADDRESS,
+            dvn_admin: ZERO_ADDRESS,
+            dvn_owner: ZERO_ADDRESS,
+            user: ZERO_ADDRESS,
+        }
+    }
+}

package/layerzero/tests/fuzzable/bytes32.cairo

@@ -0,0 +1,16 @@
+//! Fuzzable Bytes32
+
+use lz_utils::bytes::Bytes32;
+use snforge_std::fuzzable::{Fuzzable, FuzzableU256};
+
+/// Generate a random Bytes32
+pub(crate) impl FuzzableBytes32 of Fuzzable<Bytes32> {
+    fn generate() -> Bytes32 {
+        let value: u256 = FuzzableU256::generate();
+        value.into()
+    }
+
+    fn blank() -> Bytes32 {
+        Default::default()
+    }
+}

package/layerzero/tests/fuzzable/contract_address.cairo

@@ -0,0 +1,67 @@
+//! Fuzzable contract addresses
+
+use core::num::traits::Zero;
+use snforge_std::fuzzable::Fuzzable;
+use starknet::ContractAddress;
+
+/// Generate a random contract address
+pub(crate) impl FuzzableContractAddress of Fuzzable<ContractAddress> {
+    fn generate() -> ContractAddress {
+        let mut address_felt: felt252 = Fuzzable::generate();
+        let mut address: Option<ContractAddress> = address_felt.try_into();
+
+        while address.is_none() {
+            address_felt = Fuzzable::generate();
+            address = address_felt.try_into();
+        }
+
+        address.unwrap()
+    }
+
+    fn blank() -> ContractAddress {
+        Zero::zero()
+    }
+}
+
+/// Generate an array of random contract addresses
+pub(crate) impl FuzzableContractAddresses of Fuzzable<Array<ContractAddress>> {
+    fn generate() -> Array<ContractAddress> {
+        const MAX_LENGTH: usize = 10;
+        let length: usize = Fuzzable::generate() % MAX_LENGTH;
+        let mut addresses = array![];
+
+        let mut address_felt: felt252 = Fuzzable::generate();
+        let mut address: Option<ContractAddress> = address_felt.try_into();
+
+        for _ in 0..length {
+            while address.is_none() {
+                address_felt = Fuzzable::generate();
+                address = address_felt.try_into();
+            }
+
+            addresses.append(address.unwrap());
+        }
+
+        addresses
+    }
+
+    fn blank() -> Array<ContractAddress> {
+        array![]
+    }
+}
+
+// A wrapper type around an array of ContractAddress to help fuzzer argument parsing
+#[derive(Drop, Serde, Debug, PartialEq, Clone, Default)]
+pub(crate) struct ContractAddressArrayList {
+    pub arr: Array<ContractAddress>,
+}
+
+pub(crate) impl FuzzableContractAddressArrayList of Fuzzable<ContractAddressArrayList> {
+    fn blank() -> ContractAddressArrayList {
+        Default::default()
+    }
+
+    fn generate() -> ContractAddressArrayList {
+        ContractAddressArrayList { arr: FuzzableContractAddresses::generate() }
+    }
+}

package/layerzero/tests/fuzzable/dst_config.cairo

@@ -0,0 +1,37 @@
+//! Fuzzable destination configs
+
+use layerzero::workers::dvn::structs::DstConfig as DvnDstConfig;
+use layerzero::workers::executor::structs::DstConfig as ExecutorDstConfig;
+use snforge_std::fuzzable::Fuzzable;
+
+/// Generate a random DVN destination config
+pub(crate) impl FuzzableDvnDstConfig of Fuzzable<DvnDstConfig> {
+    fn generate() -> DvnDstConfig {
+        DvnDstConfig {
+            gas: Fuzzable::generate(),
+            multiplier_bps: Fuzzable::generate(),
+            floor_margin_usd: Fuzzable::generate(),
+        }
+    }
+
+    fn blank() -> DvnDstConfig {
+        Default::default()
+    }
+}
+
+/// Generate a random executor destination config
+pub(crate) impl FuzzableExecutorDstConfig of Fuzzable<ExecutorDstConfig> {
+    fn generate() -> ExecutorDstConfig {
+        ExecutorDstConfig {
+            lz_receive_base_gas: Fuzzable::generate(),
+            multiplier_bps: Fuzzable::generate(),
+            floor_margin_usd: Fuzzable::generate(),
+            native_cap: Fuzzable::generate(),
+            lz_compose_base_gas: Fuzzable::generate(),
+        }
+    }
+
+    fn blank() -> ExecutorDstConfig {
+        Default::default()
+    }
+}

package/layerzero/tests/fuzzable/eid.cairo

@@ -0,0 +1,23 @@
+//! Fuzzable endpoint IDs
+
+use core::num::traits::SaturatingSub;
+use layerzero::common::constants::MAX_V1_EID;
+use snforge_std::fuzzable::{Fuzzable, FuzzableU32};
+
+/// Endpoint ID - `u32` in the range of `[0, MAX_V1_EID)`
+#[derive(Default, Drop, PartialEq, Debug)]
+pub(crate) struct Eid {
+    pub eid: u32,
+}
+
+/// Generate a random EID
+pub(crate) impl FuzzableEid of Fuzzable<Eid> {
+    fn generate() -> Eid {
+        let eid = FuzzableU32::generate().saturating_sub(MAX_V1_EID) + MAX_V1_EID;
+        Eid { eid }
+    }
+
+    fn blank() -> Eid {
+        Default::default()
+    }
+}

package/layerzero/tests/fuzzable/eth_address.cairo

@@ -0,0 +1,17 @@
+//! Fuzzable ETH addresses
+
+use core::num::traits::Zero;
+use snforge_std::fuzzable::Fuzzable;
+use starknet::EthAddress;
+
+/// Generate a random ETH address
+pub(crate) impl FuzzableEthAddress of Fuzzable<EthAddress> {
+    fn generate() -> EthAddress {
+        let address_u256: u256 = Fuzzable::generate();
+        Into::<_, EthAddress>::into(address_u256)
+    }
+
+    fn blank() -> EthAddress {
+        Zero::zero()
+    }
+}

package/layerzero/tests/fuzzable/expiry.cairo

@@ -0,0 +1,27 @@
+//! Fuzzable expiry
+
+use core::num::traits::Bounded;
+use snforge_std::fuzzable::Fuzzable;
+
+/// Expiry - between `1` (inclusive) and `u64::MAX` (exclusive)
+#[derive(Drop, Clone, Default, PartialEq, Debug)]
+pub struct Expiry {
+    pub expiry: u64,
+}
+
+/// Generate a random expiry
+pub(crate) impl FuzzableExpiry of Fuzzable<Expiry> {
+    fn generate() -> Expiry {
+        let mut expiry = Fuzzable::generate();
+
+        while expiry == 0 || expiry == Bounded::MAX {
+            expiry = Fuzzable::generate();
+        }
+
+        Expiry { expiry }
+    }
+
+    fn blank() -> Expiry {
+        Default::default()
+    }
+}

package/layerzero/tests/fuzzable/felt_array.cairo

@@ -0,0 +1,38 @@
+//! Fuzzable felt252 array
+
+use snforge_std::fuzzable::{Fuzzable, FuzzableU32};
+
+/// Generate a random felt252 array - max length 100
+pub(crate) impl FuzzableFelt252Array of Fuzzable<Array<felt252>> {
+    fn generate() -> Array<felt252> {
+        const MAX_LENGTH: usize = 100;
+        let length = FuzzableU32::generate() % MAX_LENGTH;
+        let mut array = array![];
+
+        for _ in 0..length {
+            array.append(Fuzzable::generate());
+        }
+
+        array
+    }
+
+    fn blank() -> Array<felt252> {
+        array![]
+    }
+}
+
+// A wrapper type around an array of felt252 to help fuzzer argument parsing
+#[derive(Drop, Serde, Debug, PartialEq, Clone, Default)]
+pub(crate) struct Felt252ArrayList {
+    pub arr: Array<felt252>,
+}
+
+pub(crate) impl FuzzableFelt252ArrayList of Fuzzable<Felt252ArrayList> {
+    fn blank() -> Felt252ArrayList {
+        Default::default()
+    }
+
+    fn generate() -> Felt252ArrayList {
+        Felt252ArrayList { arr: FuzzableFelt252Array::generate() }
+    }
+}

package/layerzero/tests/fuzzable/inbound_params.cairo

@@ -0,0 +1,21 @@
+use snforge_std::fuzzable::{Fuzzable, FuzzableU64};
+use crate::endpoint::messaging_channel::utils::InboundSetupParams;
+
+// Fuzzable for InboundSetupParams with constraints and invariant
+pub impl FuzzableInboundSetupParams of Fuzzable<InboundSetupParams> {
+    fn generate() -> InboundSetupParams {
+        let mut executed_until = FuzzableU64::generate() % 50;
+        let committed_until = FuzzableU64::generate() % 50;
+        executed_until =
+            if executed_until <= committed_until {
+                executed_until
+            } else {
+                committed_until
+            };
+        InboundSetupParams { executed_until, committed_until }
+    }
+
+    fn blank() -> InboundSetupParams {
+        InboundSetupParams { executed_until: 0, committed_until: 0 }
+    }
+}

package/layerzero/tests/fuzzable/keys.cairo

@@ -0,0 +1,16 @@
+//! Fuzzable key pair
+
+use snforge_std::fuzzable::Fuzzable;
+use crate::workers::dvn::utils::{KeyPair, key_pair_from_private_key};
+
+/// Generate a random key pair
+pub(crate) impl FuzzableKeyPair of Fuzzable<KeyPair> {
+    fn generate() -> KeyPair {
+        let private_key: u256 = Fuzzable::generate();
+        key_pair_from_private_key(private_key)
+    }
+
+    fn blank() -> KeyPair {
+        key_pair_from_private_key(0)
+    }
+}

package/layerzero/tests/fuzzable/model_type.cairo

@@ -0,0 +1,27 @@
+//! Fuzzable model types
+
+use layerzero::workers::price_feed::structs::ModelType;
+use snforge_std::fuzzable::{Fuzzable, FuzzableU8};
+
+/// Generate a random model type
+pub(crate) impl FuzzableModelType of Fuzzable<ModelType> {
+    fn generate() -> ModelType {
+        const NUM_MODEL_TYPES: u8 = 3;
+        let random = FuzzableU8::generate();
+
+        match random % NUM_MODEL_TYPES {
+            0 => ModelType::DEFAULT,
+            1 => ModelType::OP_STACK,
+            2 => ModelType::ARB_STACK,
+            _ => {
+                // This is unreachable
+                assert(false, 'Invalid model type');
+                ModelType::DEFAULT
+            },
+        }
+    }
+
+    fn blank() -> ModelType {
+        ModelType::DEFAULT
+    }
+}

package/layerzero/tests/fuzzable/origin.cairo

@@ -0,0 +1,21 @@
+//! Fuzzable origin
+
+use layerzero::Origin;
+use snforge_std::fuzzable::{Fuzzable, FuzzableU32, FuzzableU64};
+use crate::fuzzable::bytes32::FuzzableBytes32;
+use crate::fuzzable::eid::FuzzableEid;
+
+/// Generate a random Origin
+pub(crate) impl FuzzableOrigin of Fuzzable<Origin> {
+    fn generate() -> Origin {
+        Origin {
+            src_eid: FuzzableEid::generate().eid,
+            sender: FuzzableBytes32::generate(),
+            nonce: FuzzableU64::generate(),
+        }
+    }
+
+    fn blank() -> Origin {
+        Origin { src_eid: 0, sender: Default::default(), nonce: 0 }
+    }
+}

package/layerzero/tests/fuzzable/price.cairo

@@ -0,0 +1,32 @@
+//! Fuzzable prices
+
+use layerzero::workers::price_feed::structs::{ArbitrumPriceExt, Price};
+use snforge_std::fuzzable::Fuzzable;
+
+/// Generate a random price
+pub(crate) impl FuzzablePrice of Fuzzable<Price> {
+    fn generate() -> Price {
+        Price {
+            gas_price_in_unit: Fuzzable::generate(),
+            gas_per_byte: Fuzzable::generate(),
+            price_ratio: Fuzzable::generate(),
+        }
+    }
+
+    fn blank() -> Price {
+        Default::default()
+    }
+}
+
+/// Generate a random arbitrum price ext
+pub(crate) impl FuzzableArbitrumPriceExt of Fuzzable<ArbitrumPriceExt> {
+    fn generate() -> ArbitrumPriceExt {
+        ArbitrumPriceExt {
+            gas_per_l2_tx: Fuzzable::generate(), gas_per_l1_call_data_byte: Fuzzable::generate(),
+        }
+    }
+
+    fn blank() -> ArbitrumPriceExt {
+        Default::default()
+    }
+}

package/layerzero/tests/fuzzable/role_admin.cairo

@@ -0,0 +1,29 @@
+//! Fuzzable role admin contract addresses
+
+use layerzero::common::constants::ZERO_ADDRESS;
+use snforge_std::fuzzable::Fuzzable;
+use starknet::ContractAddress;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+
+/// Non-zero contract address to be used as a role admin
+#[derive(Drop, Debug)]
+pub(crate) struct RoleAdmin {
+    pub address: ContractAddress,
+}
+
+/// Generate a random role admin address - not the _zero_ address
+pub(crate) impl FuzzableRoleAdmin of Fuzzable<RoleAdmin> {
+    fn generate() -> RoleAdmin {
+        let mut address = FuzzableContractAddress::generate();
+
+        while address == ZERO_ADDRESS {
+            address = FuzzableContractAddress::generate();
+        }
+
+        RoleAdmin { address }
+    }
+
+    fn blank() -> RoleAdmin {
+        RoleAdmin { address: 1.try_into().unwrap() }
+    }
+}

package/layerzero/tests/fuzzable/small_byte_array.cairo

@@ -0,0 +1,61 @@
+//! Fuzzable small byte array
+
+use snforge_std::fuzzable::{Fuzzable, generate_arg};
+
+#[derive(Drop, Serde, Debug, PartialEq, Clone, Default)]
+pub(crate) struct SmallByteArray {
+    pub ba: ByteArray,
+}
+
+/// Generate a random byte array - length `0` to `100`
+pub(crate) impl FuzzableByteArray of Fuzzable<SmallByteArray> {
+    fn blank() -> SmallByteArray {
+        Default::default()
+    }
+
+    fn generate() -> SmallByteArray {
+        let ba_len: u32 = generate_arg(0, 100);
+
+        let mut ba = "";
+        for _ in 0..ba_len {
+            // Limit only to printable characters with ASCII codes 32-126
+            let letter: u8 = generate_arg(32, 126);
+            ba.append_byte(letter);
+        }
+
+        SmallByteArray { ba }
+    }
+}
+
+/// Generate a random array of byte arrays
+pub(crate) impl FuzzableByteArrayArray of Fuzzable<Array<SmallByteArray>> {
+    fn blank() -> Array<SmallByteArray> {
+        Default::default()
+    }
+
+    fn generate() -> Array<SmallByteArray> {
+        let ba_len: u32 = generate_arg(0, 100);
+        let mut ba = array![];
+        for _ in 0..ba_len {
+            ba.append(FuzzableByteArray::generate());
+        }
+
+        ba
+    }
+}
+
+// A wrapper type around an array of SmallByteArray to help fuzzer argument parsing
+#[derive(Drop, Serde, Debug, PartialEq, Clone, Default)]
+pub(crate) struct SmallByteArrayList {
+    pub arr: Array<SmallByteArray>,
+}
+
+pub(crate) impl FuzzableSmallByteArrayList of Fuzzable<SmallByteArrayList> {
+    fn blank() -> SmallByteArrayList {
+        Default::default()
+    }
+
+    fn generate() -> SmallByteArrayList {
+        SmallByteArrayList { arr: FuzzableByteArrayArray::generate() }
+    }
+}