@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/message_lib/interface.cairo

@@ -0,0 +1,63 @@
+//! Message library interface
+
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+use crate::common::structs::messaging::{MessageLibSendResult, MessagingFee};
+use crate::common::structs::packet::Packet;
+use crate::message_lib::structs::{MessageLibType, SetConfigParam};
+
+#[derive(Drop, Serde)]
+pub enum VerificationState {
+    Verifying,
+    Verifiable,
+    Verified,
+    NotInitializable,
+}
+
+/// Interface for message libraries
+#[starknet::interface]
+pub trait IMessageLib<TContractState> {
+    fn send(
+        ref self: TContractState, packet: Packet, options: ByteArray, pay_in_lz_token: bool,
+    ) -> MessageLibSendResult;
+
+    fn verify(
+        ref self: TContractState,
+        packet_header: ByteArray,
+        payload_hash: Bytes32,
+        confirmations: u64,
+    );
+
+    fn commit(ref self: TContractState, packet_header: ByteArray, payload_hash: Bytes32);
+
+    fn quote(
+        ref self: TContractState, packet: Packet, options: ByteArray, pay_in_lz_token: bool,
+    ) -> MessagingFee;
+
+    // New functions for MessageLibManager support
+    fn message_lib_type(self: @TContractState) -> MessageLibType;
+
+    fn is_supported_send_eid(self: @TContractState, dst_eid: u32) -> bool;
+
+    fn is_supported_receive_eid(self: @TContractState, src_eid: u32) -> bool;
+
+    fn set_send_config(
+        ref self: TContractState, oapp: ContractAddress, params: Array<SetConfigParam>,
+    );
+
+    fn set_receive_config(
+        ref self: TContractState, oapp: ContractAddress, params: Array<SetConfigParam>,
+    );
+
+    fn get_send_config(
+        self: @TContractState, eid: u32, oapp: ContractAddress, config_type: u32,
+    ) -> Array<felt252>;
+
+    fn get_receive_config(
+        self: @TContractState, eid: u32, oapp: ContractAddress, config_type: u32,
+    ) -> Array<felt252>;
+
+    fn verifiable(
+        self: @TContractState, packet_header: ByteArray, payload_hash: Bytes32,
+    ) -> VerificationState;
+}

package/layerzero/src/message_lib/sml/errors.cairo

@@ -0,0 +1,23 @@
+//! Simple message library errors
+
+use lz_utils::error::{Error, format_error};
+
+#[derive(Drop)]
+pub enum SimpleMessageLibError {
+    OnlyWhitelistCaller,
+}
+
+impl ErrorNameImpl of Error<SimpleMessageLibError> {
+    fn prefix() -> ByteArray {
+        "LZ_SIMPLE_MESSAGE_LIB"
+    }
+
+    fn name(self: SimpleMessageLibError) -> ByteArray {
+        match self {
+            SimpleMessageLibError::OnlyWhitelistCaller => "ONLY_WHITELIST_CALLER",
+        }
+    }
+}
+pub fn err_only_whitelist_caller() -> ByteArray {
+    format_error(SimpleMessageLibError::OnlyWhitelistCaller, "")
+}

package/layerzero/src/message_lib/sml/events.cairo

@@ -0,0 +1,32 @@
+//! Simple message library events
+
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct PacketSent {
+    pub nonce: u64,
+    #[key]
+    pub src_eid: u32,
+    #[key]
+    pub sender: ContractAddress,
+    #[key]
+    pub dst_eid: u32,
+    #[key]
+    pub receiver: Bytes32,
+    #[key]
+    pub guid: Bytes32,
+}
+
+#[derive(Drop, PartialEq, starknet::Event, Serde)]
+pub struct PacketVerified {
+    pub nonce: u64,
+    #[key]
+    pub src_eid: u32,
+    #[key]
+    pub sender: Bytes32,
+    #[key]
+    pub dst_eid: u32,
+    #[key]
+    pub receiver: ContractAddress,
+}

package/layerzero/src/message_lib/sml/simple_message_lib.cairo

@@ -0,0 +1,312 @@
+//! Simple message library component implementation
+
+#[starknet::contract]
+pub mod SimpleMessageLib {
+    use lz_utils::bytes::Bytes32;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_caller_address};
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::Origin;
+    use crate::common::packet_v1_codec::PacketV1Codec;
+    use crate::common::structs::messaging::{
+        MessageLibSendResult, MessageReceipt, MessagingFee, Payee,
+    };
+    use crate::common::structs::packet::Packet;
+    use crate::endpoint::interfaces::endpoint::{IEndpointDispatcher, IEndpointDispatcherTrait};
+    use crate::message_lib::interface::{IMessageLib, VerificationState};
+    use crate::message_lib::sml::errors::err_only_whitelist_caller;
+    use crate::message_lib::sml::events::{PacketSent, PacketVerified};
+    use crate::message_lib::structs::{MessageLibType, SetConfigParam};
+
+    const DEFAULT_NATIVE_FEE: u256 = 1000_u256;
+    const DEFAULT_LZ_TOKEN_FEE: u256 = 999_u256;
+
+    const PAYEE_1: ContractAddress = 'payee1'.try_into().unwrap();
+    const PAYEE_2: ContractAddress = 'payee2'.try_into().unwrap();
+
+    #[derive(Drop, starknet::Store)]
+    enum MockPayeeType {
+        #[default]
+        Native,
+        LzToken,
+        MixedToken,
+    }
+
+    #[storage]
+    struct Storage {
+        send_call_count: u64,
+        should_fail: bool,
+        mock_payees_type: Option<MockPayeeType>,
+        endpoint: ContractAddress,
+        native_fee: u256,
+        lz_token_fee: u256,
+        whitelist_caller: ContractAddress,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        PacketSent: PacketSent,
+        PacketVerified: PacketVerified,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, endpoint: ContractAddress) {
+        self.send_call_count.write(0);
+        self.should_fail.write(false);
+        self.mock_payees_type.write(None);
+        self.endpoint.write(endpoint);
+        self.native_fee.write(DEFAULT_NATIVE_FEE);
+        self.lz_token_fee.write(DEFAULT_LZ_TOKEN_FEE);
+    }
+
+    #[abi(embed_v0)]
+    impl SimpleMessageLibImpl of IMessageLib<ContractState> {
+        fn send(
+            ref self: ContractState, packet: Packet, options: ByteArray, pay_in_lz_token: bool,
+        ) -> MessageLibSendResult {
+            // Increment call count
+            let count = self.send_call_count.read();
+            self.send_call_count.write(count + 1);
+
+            // Check if we should simulate failure
+            assert_with_byte_array(!self.should_fail.read(), self.get_message_lib_failure());
+
+            let payees = match self.mock_payees_type.read() {
+                Some(MockPayeeType::Native) => self.get_mock_payees(),
+                Some(MockPayeeType::LzToken) => self.get_mock_lz_payees(),
+                Some(MockPayeeType::MixedToken) => self.get_mock_mixed_payees(),
+                None => array![],
+            };
+
+            self
+                .emit(
+                    PacketSent {
+                        nonce: packet.nonce,
+                        src_eid: packet.src_eid,
+                        sender: packet.sender,
+                        dst_eid: packet.dst_eid,
+                        receiver: packet.receiver,
+                        guid: packet.guid,
+                    },
+                );
+
+            MessageLibSendResult {
+                message_receipt: MessageReceipt { guid: packet.guid, nonce: packet.nonce, payees },
+                encoded_packet: self.get_encoded_packet_data(),
+            }
+        }
+
+        fn verify(
+            ref self: ContractState,
+            packet_header: ByteArray,
+            payload_hash: Bytes32,
+            confirmations: u64,
+        ) {
+            // There is no actual verification.
+
+            self
+                .emit(
+                    PacketVerified {
+                        nonce: PacketV1Codec::nonce(@packet_header),
+                        src_eid: PacketV1Codec::src_eid(@packet_header),
+                        sender: PacketV1Codec::sender(@packet_header),
+                        dst_eid: PacketV1Codec::dst_eid(@packet_header),
+                        receiver: PacketV1Codec::receiver_address(@packet_header),
+                    },
+                );
+        }
+
+        fn commit(ref self: ContractState, packet_header: ByteArray, payload_hash: Bytes32) {
+            assert_with_byte_array(
+                get_caller_address() == self.whitelist_caller.read(), err_only_whitelist_caller(),
+            );
+
+            let receiver = PacketV1Codec::receiver_address(@packet_header);
+            let src_eid = PacketV1Codec::src_eid(@packet_header);
+            let nonce = PacketV1Codec::nonce(@packet_header);
+            let sender = PacketV1Codec::sender(@packet_header);
+
+            let origin = Origin { src_eid, sender, nonce };
+
+            let endpoint_dispatcher = IEndpointDispatcher {
+                contract_address: self.endpoint.read(),
+            };
+
+            endpoint_dispatcher.commit(origin, receiver, payload_hash);
+        }
+
+        fn quote(
+            ref self: ContractState, packet: Packet, options: ByteArray, pay_in_lz_token: bool,
+        ) -> MessagingFee {
+            MessagingFee {
+                native_fee: self.native_fee.read(),
+                lz_token_fee: if pay_in_lz_token {
+                    self.lz_token_fee.read()
+                } else {
+                    0
+                },
+            }
+        }
+
+        // ========================= New MessageLibManager Support =========================
+
+        fn message_lib_type(self: @ContractState) -> MessageLibType {
+            MessageLibType::SendAndReceive
+        }
+
+        fn is_supported_send_eid(self: @ContractState, dst_eid: u32) -> bool {
+            // SimpleMessageLib supports all EIDs for testing
+            true
+        }
+
+        fn is_supported_receive_eid(self: @ContractState, src_eid: u32) -> bool {
+            // SimpleMessageLib supports all EIDs for testing
+            true
+        }
+
+        fn set_send_config(
+            ref self: ContractState, oapp: ContractAddress, params: Array<SetConfigParam>,
+        ) { // SimpleMessageLib doesn't need configuration for testing
+        }
+
+        fn get_send_config(
+            self: @ContractState, eid: u32, oapp: ContractAddress, config_type: u32,
+        ) -> Array<felt252> {
+            // Return empty config for SimpleMessageLib
+            array![]
+        }
+
+        fn set_receive_config(
+            ref self: ContractState, oapp: ContractAddress, params: Array<SetConfigParam>,
+        ) { // SimpleMessageLib doesn't need configuration for testing
+        }
+
+        fn get_receive_config(
+            self: @ContractState, eid: u32, oapp: ContractAddress, config_type: u32,
+        ) -> Array<felt252> {
+            // Return empty config for SimpleMessageLib
+            array![]
+        }
+
+        fn verifiable(
+            self: @ContractState, packet_header: ByteArray, payload_hash: Bytes32,
+        ) -> VerificationState {
+            VerificationState::Verifiable
+        }
+    }
+
+    // Helper interface trait definition
+    #[starknet::interface]
+    pub trait ISimpleMessageLibHelpers<TContractState> {
+        fn set_should_fail(ref self: TContractState, should_fail: bool);
+        fn set_use_mock_payees(ref self: TContractState);
+        fn set_use_mock_lz_payees(ref self: TContractState);
+        fn set_use_mock_mixed_payees(ref self: TContractState);
+        fn disable_mock_payees(ref self: TContractState);
+        fn get_send_call_count(self: @TContractState) -> u64;
+        fn get_native_fee(self: @TContractState) -> u256;
+        fn get_lz_token_fee(self: @TContractState) -> u256;
+        fn set_native_fee(ref self: TContractState, fee: u256);
+        fn set_lz_token_fee(ref self: TContractState, fee: u256);
+        fn get_mock_payees(self: @TContractState) -> Array<Payee>;
+        fn get_mock_lz_payees(self: @TContractState) -> Array<Payee>;
+        fn get_mock_mixed_payees(self: @TContractState) -> Array<Payee>;
+        fn get_encoded_packet_data(self: @TContractState) -> ByteArray;
+        fn get_message_lib_failure(self: @TContractState) -> ByteArray;
+        fn set_whitelist_caller(ref self: TContractState, caller: ContractAddress);
+    }
+
+    // Helper functions for testing
+    #[abi(embed_v0)]
+    impl SimpleMessageLibHelpers of ISimpleMessageLibHelpers<ContractState> {
+        fn set_should_fail(ref self: ContractState, should_fail: bool) {
+            self.should_fail.write(should_fail);
+        }
+
+        fn set_use_mock_payees(ref self: ContractState) {
+            self.mock_payees_type.write(Some(MockPayeeType::Native));
+        }
+
+        fn set_use_mock_lz_payees(ref self: ContractState) {
+            self.mock_payees_type.write(Some(MockPayeeType::LzToken));
+        }
+
+        fn set_use_mock_mixed_payees(ref self: ContractState) {
+            self.mock_payees_type.write(Some(MockPayeeType::MixedToken));
+        }
+
+        fn disable_mock_payees(ref self: ContractState) {
+            self.mock_payees_type.write(None);
+        }
+
+        fn get_send_call_count(self: @ContractState) -> u64 {
+            self.send_call_count.read()
+        }
+
+        fn get_native_fee(self: @ContractState) -> u256 {
+            self.native_fee.read()
+        }
+
+        fn get_lz_token_fee(self: @ContractState) -> u256 {
+            self.lz_token_fee.read()
+        }
+
+        fn set_native_fee(ref self: ContractState, fee: u256) {
+            self.native_fee.write(fee)
+        }
+
+        fn set_lz_token_fee(ref self: ContractState, fee: u256) {
+            self.lz_token_fee.write(fee)
+        }
+
+        fn get_mock_payees(self: @ContractState) -> Array<Payee> {
+            let native_fee = self.native_fee.read();
+            let native_amount = native_fee / 2;
+
+            array![
+                Payee { receiver: PAYEE_1, native_amount, lz_token_amount: 0 },
+                Payee {
+                    receiver: PAYEE_2,
+                    native_amount: native_fee - native_amount,
+                    lz_token_amount: 0,
+                },
+            ]
+        }
+
+        fn get_mock_lz_payees(self: @ContractState) -> Array<Payee> {
+            let lz_token_fee = self.lz_token_fee.read();
+            let amount = lz_token_fee / 2;
+
+            array![
+                Payee { receiver: PAYEE_1, native_amount: 0, lz_token_amount: amount },
+                Payee {
+                    receiver: PAYEE_2, native_amount: 0, lz_token_amount: lz_token_fee - amount,
+                },
+            ]
+        }
+
+        fn get_mock_mixed_payees(self: @ContractState) -> Array<Payee> {
+            array![
+                Payee {
+                    receiver: PAYEE_1, native_amount: self.native_fee.read(), lz_token_amount: 0,
+                },
+                Payee {
+                    receiver: PAYEE_2, native_amount: 0, lz_token_amount: self.lz_token_fee.read(),
+                },
+            ]
+        }
+
+        fn get_encoded_packet_data(self: @ContractState) -> ByteArray {
+            "mock_encoded_packet_data"
+        }
+
+        fn get_message_lib_failure(self: @ContractState) -> ByteArray {
+            "Mock message library failure"
+        }
+
+        fn set_whitelist_caller(ref self: ContractState, caller: ContractAddress) {
+            self.whitelist_caller.write(caller);
+        }
+    }
+}

package/layerzero/src/message_lib/structs.cairo

@@ -0,0 +1,22 @@
+//! Message library structs
+
+use starknet::ContractAddress;
+
+#[derive(Copy, Drop, Serde, starknet::Store, PartialEq)]
+#[allow(starknet::store_no_default_variant)]
+pub enum MessageLibType {
+    Send,
+    Receive,
+    SendAndReceive,
+}
+
+/// Parameter for setting configuration on message libraries
+#[derive(Drop, Serde)]
+pub struct SetConfigParam {
+    pub eid: u32,
+    pub oapp: ContractAddress,
+    pub config_type: u32,
+    // this is the encoded config for the message lib
+    // this is done to allow changing the config type depending on the message lib used
+    pub config: Array<felt252>,
+}

package/layerzero/src/message_lib/uln/errors.cairo

@@ -0,0 +1,128 @@
+//! Ultra light node errors
+
+use core::byte_array::ByteArray;
+use lz_utils::error::{Error, format_error};
+use starknet::ContractAddress;
+
+#[derive(Drop)]
+pub enum UlnError {
+    MustHaveAtLeastOneDvn,
+    TooManyDvns,
+    InvalidWorkerOptions,
+    InvalidWorkerId,
+    UnsupportedOptionType,
+    InvalidOptionalDvnThreshold,
+    UnsortedDvns,
+    UnsupportedSendEid,
+    UnsupportedReceiveEid,
+    InvalidConfirmations,
+    MessageTooLarge,
+    CallerNotEndpoint,
+    InvalidTreasuryNativeFeeCap,
+    Verifying,
+    InvalidConfigType,
+}
+
+impl ErrorNameImpl of Error<UlnError> {
+    fn prefix() -> ByteArray {
+        "LZ_ULN"
+    }
+
+    fn name(self: UlnError) -> ByteArray {
+        match self {
+            UlnError::InvalidWorkerOptions => "INVALID_WORKER_OPTIONS",
+            UlnError::InvalidWorkerId => "INVALID_WORKER_ID",
+            UlnError::UnsupportedOptionType => "UNSUPPORTED_OPTION_TYPE",
+            UlnError::MustHaveAtLeastOneDvn => "MUST_HAVE_AT_LEAST_ONE_DVN",
+            UlnError::TooManyDvns => "TOO_MANY_DVNS",
+            UlnError::InvalidOptionalDvnThreshold => "INVALID_OPTIONAL_DVN_THRESHOLD",
+            UlnError::UnsortedDvns => "UNSORTED_DVNS",
+            UlnError::UnsupportedSendEid => "UNSUPPORTED_SEND_EID",
+            UlnError::UnsupportedReceiveEid => "UNSUPPORTED_RECEIVE_EID",
+            UlnError::InvalidConfirmations => "INVALID_CONFIRMATIONS",
+            UlnError::MessageTooLarge => "MESSAGE_TOO_LARGE",
+            UlnError::CallerNotEndpoint => "CALLER_NOT_ENDPOINT",
+            UlnError::InvalidTreasuryNativeFeeCap => "INVALID_TREASURY_NATIVE_FEE_CAP",
+            UlnError::Verifying => "VERIFYING",
+            UlnError::InvalidConfigType => "INVALID_CONFIG_TYPE",
+        }
+    }
+}
+
+pub fn err_invalid_worker_options(cursor: usize) -> ByteArray {
+    format_error(UlnError::InvalidWorkerOptions, format!("cursor: {}", cursor))
+}
+
+pub fn err_invalid_worker_id(worker_id: u8) -> ByteArray {
+    format_error(UlnError::InvalidWorkerId, format!("worker_id: {}", worker_id))
+}
+
+pub fn err_unsupported_option_type(option_type: u16) -> ByteArray {
+    format_error(UlnError::UnsupportedOptionType, format!("option_type: {}", option_type))
+}
+
+pub fn err_must_have_at_least_one_dvn() -> ByteArray {
+    format_error(UlnError::MustHaveAtLeastOneDvn, "")
+}
+
+pub fn err_too_many_dvns(required_count: usize, optional_count: usize) -> ByteArray {
+    format_error(
+        UlnError::TooManyDvns,
+        format!("required.count: {}, optional.count: {}", required_count, optional_count),
+    )
+}
+
+pub fn err_invalid_optional_dvn_threshold(optional_dvn_length: usize, threshold: u8) -> ByteArray {
+    format_error(
+        UlnError::InvalidOptionalDvnThreshold,
+        format!("array length: {}, threshold: {}", optional_dvn_length, threshold),
+    )
+}
+
+pub fn err_unsorted_dvns() -> ByteArray {
+    format_error(
+        UlnError::UnsortedDvns, "DVNs must be sorted in ascending order with no duplicates",
+    )
+}
+
+pub fn err_unsupported_send_eid(eid: u32) -> ByteArray {
+    format_error(UlnError::UnsupportedSendEid, format!("eid: {}", eid))
+}
+
+pub fn err_unsupported_receive_eid(eid: u32) -> ByteArray {
+    format_error(UlnError::UnsupportedReceiveEid, format!("eid: {}", eid))
+}
+
+pub fn err_invalid_confirmations() -> ByteArray {
+    format_error(UlnError::InvalidConfirmations, "confirmations must be greater than 0")
+}
+
+pub fn err_message_too_large(message_size: usize, max_message_size: usize) -> ByteArray {
+    format_error(
+        UlnError::MessageTooLarge,
+        format!("message_size: {}, max_message_size: {}", message_size, max_message_size),
+    )
+}
+
+pub fn err_caller_not_endpoint(caller: ContractAddress, endpoint: ContractAddress) -> ByteArray {
+    let caller_str: felt252 = caller.try_into().unwrap();
+    let endpoint_str: felt252 = endpoint.try_into().unwrap();
+    format_error(
+        UlnError::CallerNotEndpoint, format!("caller: {}, endpoint: {}", caller_str, endpoint_str),
+    )
+}
+
+pub fn err_invalid_treasury_native_fee_cap(old_cap: u256, new_cap: u256) -> ByteArray {
+    format_error(
+        UlnError::InvalidTreasuryNativeFeeCap,
+        format!("old_cap: {}, new_cap: {}", old_cap, new_cap),
+    )
+}
+
+pub fn err_uln_verifying() -> ByteArray {
+    format_error(UlnError::Verifying, "Verification not ready for commit")
+}
+
+pub fn err_invalid_config_type(config_type: u32) -> ByteArray {
+    format_error(UlnError::InvalidConfigType, format!("config_type: {}", config_type))
+}

package/layerzero/src/message_lib/uln/events.cairo

@@ -0,0 +1,97 @@
+//! Ultra light node events
+
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+use crate::common::structs::messaging::Payee;
+use crate::common::structs::packet::PacketHeader;
+use crate::message_lib::uln::structs::executor_config::ExecutorConfig;
+use crate::message_lib::uln::structs::uln_config::UlnConfig;
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct DefaultUlnSendConfigSet {
+    #[key]
+    pub dst_eid: u32,
+    pub config: UlnConfig,
+}
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct DefaultUlnReceiveConfigSet {
+    #[key]
+    pub src_eid: u32,
+    pub config: UlnConfig,
+}
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct OAppUlnSendConfigSet {
+    #[key]
+    pub oapp: ContractAddress,
+    pub dst_eid: u32,
+    pub config: UlnConfig,
+}
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct OAppUlnReceiveConfigSet {
+    #[key]
+    pub oapp: ContractAddress,
+    pub src_eid: u32,
+    pub config: UlnConfig,
+}
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct DefaultExecutorConfigSet {
+    #[key]
+    pub dst_eid: u32,
+    pub config: ExecutorConfig,
+}
+
+#[derive(Drop, PartialEq, starknet::Event)]
+pub struct OAppExecutorConfigSet {
+    #[key]
+    pub oapp: ContractAddress,
+    pub dst_eid: u32,
+    pub config: ExecutorConfig,
+}
+
+#[derive(Drop, starknet::Event)]
+pub struct DvnFeesPaid {
+    #[key]
+    pub oapp: ContractAddress,
+    pub payees: Array<Payee>,
+    #[key]
+    pub packet_header: PacketHeader,
+}
+
+#[derive(Drop, starknet::Event)]
+pub struct ExecutorFeePaid {
+    #[key]
+    pub oapp: ContractAddress,
+    #[key]
+    pub payee: Payee,
+    #[key]
+    pub packet_header: PacketHeader,
+}
+
+#[derive(Drop, starknet::Event)]
+pub struct TreasuryFeePaid {
+    #[key]
+    pub oapp: ContractAddress,
+    #[key]
+    pub payee: Payee,
+    #[key]
+    pub packet_header: PacketHeader,
+}
+
+#[derive(Drop, starknet::Event)]
+pub struct TreasuryNativeFeeCapSet {
+    pub native_fee_cap: u256,
+}
+
+/// This is emitted when a Payload Hash is verified by a single DVN
+#[derive(Drop, Debug, PartialEq, starknet::Event)]
+pub struct PayloadVerified {
+    #[key]
+    pub dvn: ContractAddress,
+    pub header: ByteArray,
+    pub confirmations: u256,
+    pub proof_hash: Bytes32,
+}