@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/workers/price_feed/utils.cairo

@@ -0,0 +1,37 @@
+//! Price feed test utils
+
+use layerzero::workers::price_feed::interface::{
+    ILayerZeroPriceFeedDispatcher, ILayerZeroPriceFeedSafeDispatcher, IPriceFeedDispatcher,
+    IPriceFeedSafeDispatcher,
+};
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use starknet::ContractAddress;
+
+// Constants
+pub(crate) const TEN_GWEI: u64 = 10_000_000_000;
+
+/// Price feed mock for testing
+pub(crate) struct PriceFeedDeploy {
+    pub price_feed: ContractAddress,
+    pub dispatcher: IPriceFeedDispatcher,
+    pub safe_dispatcher: IPriceFeedSafeDispatcher,
+    pub layer_zero: ILayerZeroPriceFeedDispatcher,
+    pub safe_layer_zero: ILayerZeroPriceFeedSafeDispatcher,
+}
+
+/// Deploy the price feed contract and return the price feed mock
+pub(crate) fn deploy_price_feed(
+    owner: ContractAddress, price_updater: ContractAddress,
+) -> PriceFeedDeploy {
+    let contract = declare("PriceFeed").unwrap().contract_class();
+    let calldata = array![owner.into(), price_updater.into()];
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+
+    PriceFeedDeploy {
+        price_feed: contract_address,
+        dispatcher: IPriceFeedDispatcher { contract_address },
+        safe_dispatcher: IPriceFeedSafeDispatcher { contract_address },
+        layer_zero: ILayerZeroPriceFeedDispatcher { contract_address },
+        safe_layer_zero: ILayerZeroPriceFeedSafeDispatcher { contract_address },
+    }
+}

package/libs/enumerable_set/Scarb.lock

@@ -0,0 +1,24 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "enumerable_set"
+version = "0.1.0"
+dependencies = [
+ "snforge_std",
+]
+
+[[package]]
+name = "snforge_scarb_plugin"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:8630dcf3fa4df36a3d45e6a2d053cf84c548ab154e829fece99373ae5852921c"
+
+[[package]]
+name = "snforge_std"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:981139c83359089540652c44f4a1a888c77409eedaa148377927cc63a604b67b"
+dependencies = [
+ "snforge_scarb_plugin",
+]

package/libs/enumerable_set/Scarb.toml

@@ -0,0 +1,17 @@
+[package]
+name = "enumerable_set"
+version = "0.1.0"
+edition = "2024_07"
+
+[dependencies]
+starknet = "2.12.0"
+
+[dev-dependencies]
+snforge_std = "0.48.0"
+assert_macros = "2.12.0"
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_scarb_plugin", "snforge_std"]

package/libs/enumerable_set/src/enumerable_set.cairo

@@ -0,0 +1,118 @@
+use core::hash::Hash;
+use core::num::traits::Zero;
+use core::pedersen::HashState;
+use starknet::storage::{
+    Map, Mutable, StorageMapReadAccess, StorageMapWriteAccess, StoragePath,
+    StoragePointerReadAccess, StoragePointerWriteAccess,
+};
+
+/// `EnumerableSet` struct for managing a set of values with efficient
+/// add, remove, lookup and list operations
+#[starknet::storage_node]
+pub struct EnumerableSet<T, +starknet::Store<T>, +Hash<T, HashState>> {
+    pub count: u32,
+    // slot(1-based index) to element
+    pub slot_to_element: Map<u32, T>,
+    // element to slot(1-based index)
+    pub element_to_slot: Map<T, u32>,
+}
+
+#[generate_trait]
+pub impl EnumerableSetImpl<
+    T, +starknet::Store<T>, +Hash<T, HashState>, +PartialEq<T>, +Drop<T>, +Zero<T>, +Copy<T>,
+> of EnumerableSetTrait<T> {
+    /// Adds an element to the set. Returns true if the element was added,
+    /// false if it was already present
+    fn add(self: StoragePath<Mutable<EnumerableSet<T>>>, element: T) -> bool {
+        if self.contains_mut(element) {
+            return false;
+        }
+
+        let slot = self.count.read() + 1;
+        self.slot_to_element.write(slot, element);
+        self.element_to_slot.write(element, slot);
+        self.count.write(slot);
+
+        true
+    }
+
+    /// Removes an element from the set. Returns true if the element was removed,
+    /// false if it wasn't present
+    fn remove(self: StoragePath<Mutable<EnumerableSet<T>>>, element: T) -> bool {
+        // Check if exists
+        if !self.contains_mut(element) {
+            return false;
+        }
+
+        let last_slot = self.count.read();
+        let slot = self.element_to_slot.read(element);
+
+        if slot != last_slot {
+            // Swap element to remove with the last element
+            let last_element = self.slot_to_element.read(last_slot);
+            self.element_to_slot.write(last_element, slot);
+            self.slot_to_element.write(slot, last_element);
+        }
+
+        // Remove the element
+        self.element_to_slot.write(element, 0);
+        self.slot_to_element.write(last_slot, Zero::zero());
+        self.count.write(last_slot - 1);
+
+        true
+    }
+
+    // Mutable storage function so we can use it in mutable functions
+    fn contains_mut(self: StoragePath<Mutable<EnumerableSet<T>>>, element: T) -> bool {
+        self.element_to_slot.read(element) != 0
+    }
+
+    /// Checks if an element is in the set
+    fn contains(self: StoragePath<EnumerableSet<T>>, element: T) -> bool {
+        self.element_to_slot.read(element) != 0
+    }
+
+    /// Returns the total number of elements in the set
+    fn length(self: StoragePath<EnumerableSet<T>>) -> u32 {
+        self.count.read()
+    }
+
+    /// Returns all elements in the set as an array
+    /// WARNING: This assumes the count of entries is bounded. If it is unbounded, use at(i) to
+    /// manually paginate
+    fn values(self: StoragePath<EnumerableSet<T>>) -> Array<T> {
+        let mut elements: Array<T> = array![];
+        let count = self.count.read();
+
+        for i in 1..=count {
+            let element = self.slot_to_element.read(i);
+            elements.append(element);
+        }
+
+        elements
+    }
+
+    /// Checks if the set is empty
+    fn is_empty(self: StoragePath<EnumerableSet<T>>) -> bool {
+        self.count.read() == 0
+    }
+
+    /// Clears all elements from the set
+    /// WARNING: This assumes the count of entries is bounded
+    fn clear(self: StoragePath<Mutable<EnumerableSet<T>>>) {
+        let count = self.count.read();
+
+        for i in 1..=count {
+            let element = self.slot_to_element.read(i);
+            self.element_to_slot.write(element, 0);
+            self.slot_to_element.write(i, Zero::zero());
+        }
+
+        self.count.write(0);
+    }
+
+    fn at(self: StoragePath<EnumerableSet<T>>, index: u32) -> T {
+        assert!(index < self.count.read(), "Index out of bounds");
+        self.slot_to_element.read(index + 1)
+    }
+}

package/libs/enumerable_set/src/lib.cairo

@@ -0,0 +1,4 @@
+pub mod enumerable_set;
+
+// Re-export commonly used types for easier access
+pub use crate::enumerable_set::{EnumerableSet, EnumerableSetImpl, EnumerableSetTrait};

package/libs/enumerable_set/tests/lib.cairo

@@ -0,0 +1,5 @@
+pub mod mocks {
+    pub mod mock_enumerable_set;
+}
+
+pub mod test_enumerable_set;

package/libs/enumerable_set/tests/mocks/mock_enumerable_set.cairo

@@ -0,0 +1,61 @@
+use starknet::EthAddress;
+
+/// Mock interface to test EnumerableSet functionality
+#[starknet::interface]
+pub trait IMockEnumerableSet<TContractState> {
+    fn add(ref self: TContractState, address: EthAddress) -> bool;
+    fn remove(ref self: TContractState, address: EthAddress) -> bool;
+    fn contains(self: @TContractState, address: EthAddress) -> bool;
+    fn length(self: @TContractState) -> u32;
+    fn values(self: @TContractState) -> Array<EthAddress>;
+    fn is_empty(self: @TContractState) -> bool;
+    fn clear(ref self: TContractState);
+    fn at(self: @TContractState, index: u32) -> EthAddress;
+}
+
+/// Mock contract for testing the EnumerableSet struct
+#[starknet::contract]
+pub mod MockEnumerableSet {
+    use enumerable_set::{EnumerableSet, EnumerableSetTrait};
+    use starknet::EthAddress;
+
+    #[storage]
+    struct Storage {
+        pub enumerable_set: EnumerableSet<EthAddress>,
+    }
+
+    #[abi(embed_v0)]
+    impl MockEnumerableSetImpl of super::IMockEnumerableSet<ContractState> {
+        fn add(ref self: ContractState, address: EthAddress) -> bool {
+            self.enumerable_set.add(address)
+        }
+
+        fn remove(ref self: ContractState, address: EthAddress) -> bool {
+            self.enumerable_set.remove(address)
+        }
+
+        fn contains(self: @ContractState, address: EthAddress) -> bool {
+            self.enumerable_set.contains(address)
+        }
+
+        fn length(self: @ContractState) -> u32 {
+            self.enumerable_set.length()
+        }
+
+        fn values(self: @ContractState) -> Array<EthAddress> {
+            self.enumerable_set.values()
+        }
+
+        fn is_empty(self: @ContractState) -> bool {
+            self.enumerable_set.is_empty()
+        }
+
+        fn clear(ref self: ContractState) {
+            self.enumerable_set.clear()
+        }
+
+        fn at(self: @ContractState, index: u32) -> EthAddress {
+            self.enumerable_set.at(index)
+        }
+    }
+}

package/libs/enumerable_set/tests/test_enumerable_set.cairo

@@ -0,0 +1,379 @@
+use starknet::EthAddress;
+use starknet::storage::{StorageMapReadAccess, StoragePointerReadAccess};
+use crate::mocks::mock_enumerable_set::{IMockEnumerableSet, MockEnumerableSet};
+
+fn signer1() -> EthAddress {
+    Into::<u256, EthAddress>::into(0x9b6ababd080456f900ed64e74d122ff9ca40daa1)
+}
+
+fn signer2() -> EthAddress {
+    Into::<u256, EthAddress>::into(0xc221797af9445f00b4b0ff2c4853ce7bfb968b07)
+}
+
+fn signer3() -> EthAddress {
+    Into::<u256, EthAddress>::into(0x1234567890abcdef1234567890abcdef12345678)
+}
+
+fn zero_element() -> EthAddress {
+    Into::<u256, EthAddress>::into(0)
+}
+
+fn enumerable_set_contract_state() -> MockEnumerableSet::ContractState {
+    MockEnumerableSet::contract_state_for_testing()
+}
+
+fn assert_signer_at_slot_with_count(
+    contract: @MockEnumerableSet::ContractState, signer: EthAddress, slot: u32, count: u32,
+) {
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer), slot);
+    assert_eq!(contract.enumerable_set.slot_to_element.read(slot), signer);
+    assert_eq!(contract.contains(signer), true);
+    assert_eq!(contract.enumerable_set.count.read(), count);
+}
+
+#[test]
+fn test_enumerable_set_add() {
+    let mut contract = enumerable_set_contract_state();
+    contract.add(signer1());
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 1);
+}
+
+#[test]
+fn test_enumerable_set_add_multiple() {
+    let mut contract = enumerable_set_contract_state();
+    let signers = array![signer1(), signer2(), signer3()];
+
+    for (i, signer) in signers.into_iter().enumerate() {
+        let result = contract.add(signer);
+        assert_eq!(result, true);
+        assert_signer_at_slot_with_count(@contract, signer, i + 1, i + 1);
+    }
+}
+
+#[test]
+fn test_enumerable_set_add_duplicate() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add element first time
+    let result1 = contract.add(signer1());
+    assert_eq!(result1, true);
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 1);
+
+    // Try to add same element again
+    let result2 = contract.add(signer1());
+    assert_eq!(result2, false);
+    // Should still be at slot 1 and count 1
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 1);
+}
+
+#[test]
+fn test_enumerable_set_remove_middle_element() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements first
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+    assert_eq!(contract.enumerable_set.count.read(), 3);
+
+    // Remove middle element (signer2 at slot 2)
+    let result = contract.remove(signer2());
+    assert_eq!(result, true);
+    assert_eq!(contract.enumerable_set.count.read(), 2);
+    assert_eq!(contract.contains(signer2()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer2()), 0); // Reset to 0
+
+    // Due to swap-and-pop, signer3 (was at slot 3) should now be at slot 2
+    assert_signer_at_slot_with_count(@contract, signer3(), 2, 2);
+
+    // signer1 should still be at slot 1
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 2);
+}
+
+#[test]
+fn test_enumerable_set_remove_last_element() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Remove last element (signer3 at slot 3)
+    let result = contract.remove(signer3());
+    assert_eq!(result, true);
+    assert_eq!(contract.enumerable_set.count.read(), 2);
+    assert_eq!(contract.contains(signer3()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer3()), 0); // Reset to 0
+
+    // Other elements should remain unchanged
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 2);
+    assert_signer_at_slot_with_count(@contract, signer2(), 2, 2);
+}
+
+#[test]
+fn test_enumerable_set_remove_first_element() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Remove first element (signer1 at slot 1)
+    let result = contract.remove(signer1());
+    assert_eq!(result, true);
+    assert_eq!(contract.enumerable_set.count.read(), 2);
+    assert_eq!(contract.contains(signer1()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 0); // Reset to 0
+
+    // The last element (signer3, was at slot 3) should have moved to slot 1
+    assert_signer_at_slot_with_count(@contract, signer3(), 1, 2);
+
+    // signer2 should still be at slot 2
+    assert_signer_at_slot_with_count(@contract, signer2(), 2, 2);
+}
+
+#[test]
+fn test_enumerable_set_remove_nonexistent() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add one element
+    contract.add(signer1());
+    assert_eq!(contract.enumerable_set.count.read(), 1);
+
+    // Try to remove element that doesn't exist
+    let result = contract.remove(signer2());
+    assert_eq!(result, false);
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 1);
+}
+
+#[test]
+fn test_enumerable_set_remove_from_empty() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Try to remove from empty set
+    let result = contract.remove(signer1());
+    assert_eq!(result, false);
+    assert_eq!(contract.enumerable_set.count.read(), 0);
+}
+
+#[test]
+fn test_enumerable_set_clear() {
+    let mut contract = enumerable_set_contract_state();
+    let signers = array![signer1(), signer2(), signer3()];
+
+    // Add multiple elements
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+    assert_eq!(contract.enumerable_set.count.read(), 3);
+
+    // Clear all elements
+    contract.clear();
+    assert_eq!(contract.enumerable_set.count.read(), 0);
+
+    // Verify all elements are no longer members
+    for signer in signers {
+        assert_eq!(contract.contains(signer), false);
+        assert_eq!(contract.enumerable_set.element_to_slot.read(signer), 0);
+    }
+}
+
+#[test]
+fn test_enumerable_set_single_element_operations() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add single element
+    contract.add(signer1());
+    assert_eq!(contract.enumerable_set.count.read(), 1);
+    assert_eq!(contract.contains(signer1()), true);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 1);
+    assert_eq!(contract.enumerable_set.slot_to_element.read(1), signer1());
+
+    // Remove single element
+    let result = contract.remove(signer1());
+    assert_eq!(result, true);
+    assert_eq!(contract.enumerable_set.count.read(), 0);
+    assert_eq!(contract.contains(signer1()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 0);
+}
+
+#[test]
+fn test_enumerable_set_complex_operations() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add multiple elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+    assert_eq!(contract.enumerable_set.count.read(), 3);
+
+    // Remove middle one (signer2 at slot 2). signer3 (idx 3) moves to idx 2.
+    contract.remove(signer2());
+    assert_eq!(contract.contains(signer2()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer2()), 0);
+    assert_signer_at_slot_with_count(@contract, signer3(), 2, 2);
+
+    // Add it back - signer2 should get the next available slot (3)
+    contract.add(signer2());
+    assert_eq!(contract.contains(signer2()), true);
+    assert_signer_at_slot_with_count(@contract, signer2(), 3, 3);
+
+    // Verify all elements are present and at their correct current indices
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 3);
+    assert_signer_at_slot_with_count(@contract, signer3(), 2, 3);
+    assert_signer_at_slot_with_count(@contract, signer2(), 3, 3);
+}
+
+#[test]
+fn test_enumerable_set_contains() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Initially empty - should not contain any element
+    assert_eq!(contract.contains(signer1()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 0);
+
+    // Add element
+    contract.add(signer1());
+    assert_eq!(contract.contains(signer1()), true);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 1);
+
+    // Should not contain other elements
+    assert_eq!(contract.contains(signer2()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer2()), 0);
+
+    // Remove element
+    contract.remove(signer1());
+    assert_eq!(contract.contains(signer1()), false);
+    assert_eq!(contract.enumerable_set.element_to_slot.read(signer1()), 0);
+}
+
+
+#[test]
+fn test_enumerable_set_values() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Initially empty
+    let elements = contract.values();
+    assert_eq!(elements.len(), 0);
+    assert_eq!(contract.enumerable_set.count.read(), 0);
+
+    // Add one element
+    contract.add(signer1());
+    let elements = contract.values();
+    assert_eq!(elements.len(), 1);
+    assert_eq!(*elements[0], signer1()); // values() returns 0-sloted array
+    assert_eq!(contract.enumerable_set.slot_to_element.read(1), signer1()); // storage is 1-sloted
+
+    // Add more elements
+    contract.add(signer2());
+    contract.add(signer3());
+    let elements = contract.values();
+    assert_eq!(elements.len(), 3);
+    assert_eq!(*elements[0], signer1());
+    assert_eq!(*elements[1], signer2());
+    assert_eq!(*elements[2], signer3());
+
+    // Verify against storage (1-sloted)
+    assert_eq!(contract.enumerable_set.slot_to_element.read(1), signer1());
+    assert_eq!(contract.enumerable_set.slot_to_element.read(2), signer2());
+    assert_eq!(contract.enumerable_set.slot_to_element.read(3), signer3());
+}
+
+#[test]
+fn test_enumerable_set_values_after_removal() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Remove middle element (signer2 from slot 2)
+    // signer3 (from slot 3) moves to slot 2
+    contract.remove(signer2());
+
+    // Get all should return remaining elements
+    let elements = contract.values();
+    assert_eq!(elements.len(), 2);
+
+    // Due to swap-and-pop, order is signer1, then signer3
+    assert_eq!(*elements[0], signer1());
+    assert_eq!(*elements[1], signer3());
+
+    // Verify against storage (1-sloted)
+    assert_signer_at_slot_with_count(@contract, signer1(), 1, 2);
+    assert_signer_at_slot_with_count(@contract, signer3(), 2, 2);
+}
+
+#[test]
+fn test_enumerable_set_read_functions_consistency() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Test consistency between different read methods
+    let length = contract.length(); // Should be 3
+    let count = contract.enumerable_set.count.read(); // Should be 3
+    let elements_array = contract.values(); // 0-sloted array: [s1, s2, s3]
+    let is_empty = contract.is_empty();
+
+    assert_eq!(length, count);
+    assert_eq!(length, elements_array.len());
+    assert_eq!(is_empty, length == 0);
+
+    // Test each element is accessible by slot and contained in set
+    // Loop uses 0-based slot for the array, but 1-based for storage access
+    for i_zero_based in 0..length {
+        let one_based_slot = i_zero_based + 1;
+        let element_from_values = *elements_array[i_zero_based];
+        let element_by_storage_slot = contract.enumerable_set.slot_to_element.read(one_based_slot);
+
+        assert_eq!(element_by_storage_slot, element_from_values);
+        assert_eq!(contract.contains(element_by_storage_slot), true);
+        assert_eq!(
+            contract.enumerable_set.element_to_slot.read(element_by_storage_slot), one_based_slot,
+        );
+    }
+}
+
+#[test]
+fn test_get_by_index() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Get elements by index
+    assert_eq!(contract.at(0), signer1());
+    assert_eq!(contract.at(1), signer2());
+    assert_eq!(contract.at(2), signer3());
+}
+
+#[test]
+#[should_panic]
+fn test_get_by_index_out_of_bounds() {
+    let mut contract = enumerable_set_contract_state();
+
+    // Add elements
+    let signers = array![signer1(), signer2(), signer3()];
+    for signer in signers.clone() {
+        contract.add(signer);
+    }
+
+    // Try to get element at index 3 (out of bounds)
+    assert_eq!(contract.at(3), signer1());
+}

package/libs/lz_utils/Scarb.lock

@@ -0,0 +1,24 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "lz_utils"
+version = "0.1.0"
+dependencies = [
+ "snforge_std",
+]
+
+[[package]]
+name = "snforge_scarb_plugin"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:8630dcf3fa4df36a3d45e6a2d053cf84c548ab154e829fece99373ae5852921c"
+
+[[package]]
+name = "snforge_std"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:981139c83359089540652c44f4a1a888c77409eedaa148377927cc63a604b67b"
+dependencies = [
+ "snforge_scarb_plugin",
+]

package/libs/lz_utils/Scarb.toml

@@ -0,0 +1,17 @@
+[package]
+name = "lz_utils"
+version = "0.1.0"
+edition = "2024_07"
+
+[dependencies]
+starknet = "2.12.0"
+
+[dev-dependencies]
+snforge_std = "0.48.0"
+assert_macros = "2.12.0"
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_scarb_plugin", "snforge_std"]