@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/lib.cairo

@@ -0,0 +1,177 @@
+// Test library for LayerZero protocol
+
+pub mod utils;
+
+pub mod mocks {
+    pub mod composer_target;
+    pub mod endpoint;
+    pub mod messaging_channel {
+        pub mod interface;
+        pub mod messaging_channel;
+    }
+    pub mod messaging_composer;
+    pub mod erc20 {
+        pub mod erc20;
+        pub mod interface;
+    }
+    pub mod message_lib_manager;
+    pub mod oapp_core {
+        pub mod interface;
+        pub mod oapp_core;
+    }
+    pub mod oapp_options_type3;
+    pub mod oft_core {
+        pub mod interface;
+        pub mod oft_core;
+    }
+    pub mod message_inspector {
+        pub mod message_inspector;
+    }
+    pub mod receiver;
+    pub mod treasury {
+        pub mod lz_token_fee_lib;
+        pub mod treasury;
+    }
+    pub mod uln_config {
+        pub mod interface;
+        pub mod uln_config;
+    }
+    pub mod workers {
+        pub mod base;
+        pub mod dvn;
+        pub mod executor {
+            pub mod decode {
+                pub mod decode;
+                pub mod interface;
+            }
+            pub mod executor;
+        }
+    }
+}
+pub mod common {
+    pub mod test_constants;
+    pub mod test_guid;
+    pub mod test_packet_v1_codec;
+    pub mod utils;
+}
+
+pub mod endpoint {
+    pub mod test_endpoint_commit;
+    pub mod test_endpoint_lzreceive;
+    pub mod test_endpoint_quote;
+    pub mod test_endpoint_send;
+    pub mod message_lib_manager {
+        pub mod test_message_lib_manager;
+        pub mod utils;
+    }
+    pub mod messaging_channel {
+        pub mod test_messaging_channel;
+        pub mod utils;
+    }
+    pub mod utils;
+    pub mod messaging_composer {
+        pub mod test_messaging_composer;
+        pub mod utils;
+    }
+}
+
+pub mod workers {
+    pub mod base {
+        pub mod test_worker_base;
+        pub mod utils;
+    }
+    pub mod dvn {
+        pub mod fee_lib {
+            pub mod test_dvn_fee_lib;
+        }
+        pub mod test_dvn;
+        pub mod test_dvn_options;
+        pub mod utils;
+    }
+    pub mod executor {
+        pub mod fee_lib {
+            pub mod test_executor_fee_lib;
+        }
+        pub mod test_decode;
+        #[feature("safe_dispatcher")]
+        pub mod test_executor;
+        pub mod utils;
+    }
+    pub mod price_feed {
+        pub mod test_price_feed;
+        pub mod utils;
+    }
+}
+
+pub mod message_lib {
+    #[feature("safe_dispatcher")]
+    pub mod sml {
+        pub mod test_simple_message_lib;
+    }
+    pub mod uln {
+        pub mod test_uln_admin;
+        pub mod test_uln_config;
+        pub mod test_uln_config_storage_node;
+        pub mod test_uln_executor_config;
+        pub mod test_uln_options;
+        pub mod test_uln_quote;
+        pub mod test_uln_receive;
+        pub mod test_uln_send;
+        pub mod utils;
+    }
+}
+
+pub mod oapps {
+    pub mod common {
+        pub mod test_oapp_options_type_3;
+    }
+    pub mod test_counter;
+    pub mod test_oapp_core;
+    pub mod oft {
+        pub mod test_oft_adapter;
+        pub mod test_oft_compose_msg_codec;
+        pub mod test_oft_core;
+        pub mod test_oft_msg_codec;
+    }
+}
+
+#[feature("safe_dispatcher")]
+pub mod treasury {
+    pub mod test_lz_token_fee_lib;
+    pub mod test_treasury;
+    pub mod utils;
+}
+
+
+/// Fuzzable types for testing
+pub mod fuzzable {
+    pub mod blockchain_config;
+    pub mod bytes32;
+    pub mod contract_address;
+    pub mod dst_config;
+    pub mod eid;
+    pub mod eth_address;
+    pub mod expiry;
+    pub mod felt_array;
+    pub mod inbound_params;
+    pub mod keys;
+    pub mod model_type;
+    pub mod origin;
+    pub mod price;
+    pub mod role_admin;
+    pub mod small_byte_array;
+}
+
+/// End-to-end tests
+#[feature("safe_dispatcher")]
+pub mod e2e {
+    pub mod oft_utils;
+    pub mod test_counter_with_sml;
+    pub mod test_counter_with_uln;
+    pub mod test_dvn;
+    pub mod test_lz_token;
+    pub mod test_oft_compose_with_uln;
+    pub mod test_oft_with_sml;
+    pub mod test_oft_with_uln;
+    pub mod utils;
+}

package/layerzero/tests/message_lib/sml/test_simple_message_lib.cairo

@@ -0,0 +1,224 @@
+//! Simple message library tests
+
+use layerzero::Packet;
+use layerzero::common::packet_v1_codec::PacketV1Codec;
+use layerzero::message_lib::interface::{
+    IMessageLibDispatcher, IMessageLibDispatcherTrait, IMessageLibSafeDispatcher,
+    IMessageLibSafeDispatcherTrait,
+};
+use layerzero::message_lib::sml::errors::err_only_whitelist_caller;
+use layerzero::message_lib::sml::events::{PacketSent, PacketVerified};
+use layerzero::message_lib::sml::simple_message_lib::SimpleMessageLib;
+use layerzero::message_lib::sml::simple_message_lib::SimpleMessageLib::{
+    ISimpleMessageLibHelpersDispatcher, ISimpleMessageLibHelpersDispatcherTrait,
+};
+use lz_utils::bytes::Bytes32;
+use snforge_std::{
+    ContractClassTrait, DeclareResultTrait, EventSpyAssertionsTrait, declare, spy_events,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::{assert_panic_with_error, cheat_caller_address_once};
+use crate::endpoint::utils::{EndpointMock, deploy_mock_endpoint};
+use crate::fuzzable::bytes32::FuzzableBytes32;
+use crate::fuzzable::contract_address::{FuzzableContractAddress, FuzzableContractAddresses};
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+
+const SRC_EID: u32 = 1;
+const DST_EID: u32 = 2;
+
+fn create_mock_packet() -> Packet {
+    Packet {
+        nonce: 1,
+        src_eid: SRC_EID,
+        sender: 'sender'.try_into().unwrap(),
+        dst_eid: DST_EID,
+        receiver: Bytes32 { value: 'receiver'.into() },
+        guid: Bytes32 { value: 'guid'.into() },
+        message: "message",
+    }
+}
+
+fn deploy_mock_simple_message_library(
+    endpoint: ContractAddress,
+) -> (IMessageLibDispatcher, IMessageLibSafeDispatcher, ISimpleMessageLibHelpersDispatcher) {
+    let contract = declare("SimpleMessageLib").unwrap().contract_class();
+    let (contract_address, _) = contract.deploy(@array![endpoint.into()]).unwrap();
+
+    (
+        IMessageLibDispatcher { contract_address },
+        IMessageLibSafeDispatcher { contract_address },
+        ISimpleMessageLibHelpersDispatcher { contract_address },
+    )
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_mock_constructor(endpoint: ContractAddress) {
+    deploy_mock_simple_message_library(endpoint);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_send_paying_native_payees(endpoint: ContractAddress, native_fee: u256) {
+    let (dispatcher, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    helper_dispatcher.set_use_mock_payees();
+    helper_dispatcher.set_native_fee(native_fee);
+
+    let result = dispatcher.send(create_mock_packet(), "", false);
+    let payees = result.message_receipt.payees;
+
+    assert_eq!(payees.len(), 2);
+    assert_eq!(*payees[0].native_amount, native_fee / 2);
+    assert_eq!(*payees[0].lz_token_amount, 0);
+    assert_eq!(*payees[1].native_amount, native_fee - native_fee / 2);
+    assert_eq!(*payees[1].lz_token_amount, 0);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_send_paying_lz_token_payees(endpoint: ContractAddress, lz_token_fee: u256) {
+    let (dispatcher, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    helper_dispatcher.set_use_mock_lz_payees();
+    helper_dispatcher.set_lz_token_fee(lz_token_fee);
+
+    let result = dispatcher.send(create_mock_packet(), "", true);
+    let payees = result.message_receipt.payees;
+
+    assert_eq!(payees.len(), 2);
+    assert_eq!(*payees[0].native_amount, 0);
+    assert_eq!(*payees[0].lz_token_amount, lz_token_fee / 2);
+    assert_eq!(*payees[1].native_amount, 0);
+    assert_eq!(*payees[1].lz_token_amount, lz_token_fee - lz_token_fee / 2);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_send_paying_mixed_payees(endpoint: ContractAddress, native_fee: u256, lz_token_fee: u256) {
+    let (dispatcher, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    helper_dispatcher.set_use_mock_mixed_payees();
+    helper_dispatcher.set_native_fee(native_fee);
+    helper_dispatcher.set_lz_token_fee(lz_token_fee);
+
+    let result = dispatcher.send(create_mock_packet(), "", true);
+    let payees = result.message_receipt.payees;
+
+    assert_eq!(payees.len(), 2);
+    assert_eq!(*payees[0].native_amount, native_fee);
+    assert_eq!(*payees[0].lz_token_amount, 0);
+    assert_eq!(*payees[1].native_amount, 0);
+    assert_eq!(*payees[1].lz_token_amount, lz_token_fee);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_send_event(endpoint: ContractAddress, native_fee: u256) {
+    let (dispatcher, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    helper_dispatcher.set_use_mock_payees();
+    helper_dispatcher.set_native_fee(native_fee);
+
+    let mut spy = spy_events();
+
+    let packet = create_mock_packet();
+    dispatcher.send(packet.clone(), "", false);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    dispatcher.contract_address,
+                    SimpleMessageLib::Event::PacketSent(
+                        PacketSent {
+                            nonce: packet.nonce,
+                            src_eid: packet.src_eid,
+                            sender: packet.sender,
+                            dst_eid: packet.dst_eid,
+                            receiver: packet.receiver,
+                            guid: packet.guid,
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_verify_event(endpoint: ContractAddress, payload_hash: Bytes32, confirmations: u64) {
+    let (dispatcher, _, _) = deploy_mock_simple_message_library(endpoint);
+
+    let mut spy = spy_events();
+
+    let packet = create_mock_packet();
+
+    dispatcher.verify(PacketV1Codec::encode_header(@packet), payload_hash, confirmations);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    dispatcher.contract_address,
+                    SimpleMessageLib::Event::PacketVerified(
+                        PacketVerified {
+                            nonce: packet.nonce,
+                            src_eid: packet.src_eid,
+                            sender: packet.sender.into(),
+                            dst_eid: packet.dst_eid,
+                            receiver: packet.receiver.try_into().unwrap(),
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_commit_with_whitelist_caller(
+    endpoint_owner: ContractAddress, eid: Eid, executor: ContractAddress, payload_hash: Bytes32,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let (dispatcher, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    helper_dispatcher.set_whitelist_caller(executor);
+    cheat_caller_address_once(dispatcher.contract_address, executor);
+    dispatcher.commit(PacketV1Codec::encode_header(@create_mock_packet()), payload_hash);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_commit_with_non_whitelist_caller(endpoint: ContractAddress, payload_hash: Bytes32) {
+    let (_, safe_dispatcher, _) = deploy_mock_simple_message_library(endpoint);
+
+    let result = safe_dispatcher
+        .commit(PacketV1Codec::encode_header(@create_mock_packet()), payload_hash);
+
+    assert_panic_with_error(result, err_only_whitelist_caller());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_native_fee(endpoint: ContractAddress, fee: u256) {
+    let (_, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    assert_eq!(helper_dispatcher.get_native_fee(), 1000);
+
+    helper_dispatcher.set_native_fee(fee);
+
+    assert_eq!(helper_dispatcher.get_native_fee(), fee);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_lz_token_fee(endpoint: ContractAddress, fee: u256) {
+    let (_, _, helper_dispatcher) = deploy_mock_simple_message_library(endpoint);
+
+    assert_eq!(helper_dispatcher.get_lz_token_fee(), 999);
+
+    helper_dispatcher.set_lz_token_fee(fee);
+
+    assert_eq!(helper_dispatcher.get_lz_token_fee(), fee);
+}