@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/workers/base/events.cairo

@@ -0,0 +1,43 @@
+//! Base worker events
+
+use starknet::ContractAddress;
+
+/// Event emitted when the price feed address is updated
+#[derive(Drop, starknet::Event)]
+pub struct PriceFeedSet {
+    #[key]
+    pub old_price_feed: ContractAddress,
+    #[key]
+    pub new_price_feed: ContractAddress,
+}
+
+/// Event emitted when fees are withdrawn
+#[derive(Drop, starknet::Event)]
+pub struct FeeWithdrawn {
+    #[key]
+    pub to: ContractAddress,
+    pub amount: u256,
+}
+
+/// Event emitted when the supported option type for an EID is set
+#[derive(Drop, starknet::Event)]
+pub struct SupportedOptionTypeSet {
+    #[key]
+    pub eid: u32,
+    pub option_type: ByteArray,
+}
+
+/// Event emitted when the default multiplier basis points is set
+#[derive(Drop, starknet::Event)]
+pub struct DefaultMultiplierBpsSet {
+    pub default_multiplier_bps: u16,
+}
+
+/// Event emitted when the worker fee lib address is updated
+#[derive(Drop, starknet::Event)]
+pub struct WorkerFeeLibSet {
+    #[key]
+    pub old_worker_fee_lib: ContractAddress,
+    #[key]
+    pub new_worker_fee_lib: ContractAddress,
+}

package/layerzero/src/workers/base/interface.cairo

@@ -0,0 +1,93 @@
+//! Base worker interface
+
+use starknet::ContractAddress;
+
+/// Interface for the base worker component
+#[starknet::interface]
+pub trait IWorkerBase<TContractState> {
+    // ================================== Only Default Admin ===============================
+
+    /// Pause the contract (only default admin)
+    fn pause(ref self: TContractState);
+
+    /// Unpause the contract (only default admin)
+    fn unpause(ref self: TContractState);
+
+    // ===================================== Only Admin =====================================
+
+    /// Sets the price feed worker address
+    ///
+    /// # Arguments
+    ///
+    /// * `price_feed`: The address of the price feed worker
+    ///
+    /// @dev This function is only callable by the admin role.
+    fn set_price_feed(ref self: TContractState, price_feed: ContractAddress);
+
+    /// Sets the supported option type for an endpointID
+    ///
+    /// # Arguments
+    ///
+    /// * `eid`: The EID to set the supported option type for
+    /// * `option_type`: The option type to set for the EID
+    ///
+    /// @dev This function is only callable by the admin role.
+    fn set_supported_option_type(ref self: TContractState, eid: u32, option_type: ByteArray);
+
+    /// Sets the default multiplier basis points
+    ///
+    /// # Arguments
+    ///
+    /// * `default_multiplier_bps`: The default multiplier basis points to set
+    ///
+    /// @dev This function is only callable by the admin role.
+    fn set_default_multiplier_bps(ref self: TContractState, default_multiplier_bps: u16);
+
+    /// Withdraw collected fees (only admin)
+    fn withdraw_fee(
+        ref self: TContractState, token_address: ContractAddress, to: ContractAddress, amount: u256,
+    );
+
+    /// Sets the worker fee lib address
+    ///
+    /// # Arguments
+    ///
+    /// * `worker_fee_lib`: The address of the worker fee lib
+    ///
+    /// @dev This function is only callable by the admin role.
+    fn set_worker_fee_lib(ref self: TContractState, worker_fee_lib: ContractAddress);
+
+    // ======================================= View ========================================
+
+    /// Gets the current price feed address
+    ///
+    /// # Returns
+    ///
+    /// The current price feed worker's address
+    fn get_price_feed(self: @TContractState) -> ContractAddress;
+
+    /// Gets the supported option type for a given EID
+    ///
+    /// # Arguments
+    ///
+    /// * `eid`: The EID to get the supported option type for
+    ///
+    /// # Returns
+    ///
+    /// The supported option type for the EID
+    fn get_supported_option_type(self: @TContractState, eid: u32) -> ByteArray;
+
+    /// Gets the default multiplier basis points
+    ///
+    /// # Returns
+    ///
+    /// The default multiplier basis points
+    fn get_default_multiplier_bps(self: @TContractState) -> u16;
+
+    /// Gets the current worker fee lib address
+    ///
+    /// # Returns
+    ///
+    /// The current worker fee lib address
+    fn get_worker_fee_lib(self: @TContractState) -> ContractAddress;
+}

package/layerzero/src/workers/base/structs.cairo

@@ -0,0 +1,10 @@
+use starknet::ContractAddress;
+
+#[derive(Drop, Serde, Clone)]
+pub struct QuoteParams {
+    pub dst_eid: u32,
+    pub sender: ContractAddress,
+    pub confirmations: u64,
+    pub calldata_size: u32,
+    pub options: ByteArray,
+}

package/layerzero/src/workers/common.cairo

@@ -0,0 +1,59 @@
+use crate::common::constants::{DEFAULT_BPS, NATIVE_DECIMALS_RATE};
+
+/// Apply premium and floor margin to the fee
+///
+/// Returns the maximum between the fee with a multiplier and fee with the floor margin.
+///
+/// # Arguments
+///
+/// * `fee` - fee to apply premium to
+/// * `bps` - base points to apply premium to, where 10000 = 100%
+/// * `default_bps` - default bps to apply premium to
+/// * `margin_usd` - margin in usd
+/// * `native_price_usd` - native price in usd
+///
+/// # Returns
+///
+/// * `fee_with_premium` - fee with premium applied
+pub fn apply_premium_and_floor_margin(
+    fee: u256, bps: u16, default_bps: u16, margin_usd: u128, native_price_usd: u128,
+) -> u256 {
+    let multiplier_bps = if bps == 0 {
+        default_bps
+    } else {
+        bps
+    };
+
+    // fee with multiplier, divides by DEFAULT_BPS to get the percentage
+    let fee_with_multiplier = (fee * multiplier_bps.into()) / DEFAULT_BPS;
+    if native_price_usd == 0 || margin_usd == 0 {
+        return fee_with_multiplier;
+    }
+
+    // fee with floor margin, divides by native_price_usd to get the amount of native tokens
+    let fee_with_floor_margin = fee
+        + (margin_usd.into() * NATIVE_DECIMALS_RATE) / native_price_usd.into();
+
+    // return the max
+    if fee_with_floor_margin > fee_with_multiplier {
+        fee_with_floor_margin
+    } else {
+        fee_with_multiplier
+    }
+}
+
+pub fn convert_and_apply_premium_to_value(
+    value: u256, ratio: u128, denom: u128, bps: u16, default_bps: u16,
+) -> u256 {
+    let multiplier_bps = if bps == 0 {
+        default_bps
+    } else {
+        bps
+    };
+
+    if value > 0 {
+        (((value * ratio.into()) / denom.into()) * multiplier_bps.into()) / DEFAULT_BPS
+    } else {
+        0
+    }
+}

package/layerzero/src/workers/dvn/constants.cairo

@@ -0,0 +1,11 @@
+//! DVN constants
+
+/// The raw bytes of the signature are 65 bytes long, the first 64 bytes are the signature, and the
+/// last byte is the recovery ID.
+pub const SIGNATURE_RAW_BYTES: usize = 65;
+
+/// encoded: funcSigHash + params -> 4  + (32 * 2)
+pub const EXECUTE_FIXED_BYTES: u32 = 68;
+
+/// callData(verify) = 228 (4 + 64 + 81 + 15 + 32 + 32), padded to 32 = 256 + 64 = 320
+pub const VERIFY_BYTES: u32 = 320;

package/layerzero/src/workers/dvn/dvn.cairo

@@ -0,0 +1,338 @@
+//! DVN contract implementation
+
+/// DVN contract
+///
+/// The DVN contract is a key component of LayerZero's security and validation model, acting as an
+/// on-chain representation of an off-chain verification network. Its primary responsibility is to
+/// attest to the validity of cross-chain messages. When a message is sent from another chain to
+/// Starknet, a DVN is tasked with verifying that message. This contract manages the on-chain part
+/// of that process: quoting the price for verification, and providing the mechanism for a trusted
+/// party (the DVN's agent) to submit the verified message for execution.
+#[starknet::contract]
+pub mod Dvn {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use core::num::traits::Zero;
+    use lz_utils::bytes::Bytes32;
+    use lz_utils::keccak::keccak256;
+    use multisig::MultisigComponent;
+    use openzeppelin::access::accesscontrol::AccessControlComponent;
+    use openzeppelin::introspection::src5::SRC5Component;
+    use openzeppelin::security::pausable::PausableComponent;
+    use openzeppelin::security::reentrancyguard::ReentrancyGuardComponent;
+    use openzeppelin::upgrades::upgradeable::UpgradeableComponent;
+    use openzeppelin::upgrades::upgradeable::UpgradeableComponent::InternalTrait as UpgradeableInternalTrait;
+    use starknet::account::Call;
+    use starknet::storage::{
+        Map, StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess,
+        StoragePointerWriteAccess,
+    };
+    use starknet::syscalls::call_contract_syscall;
+    use starknet::{
+        ClassHash, ContractAddress, EthAddress, get_block_timestamp, get_contract_address,
+    };
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::workers::access_control::ADMIN_ROLE;
+    use crate::workers::base::base::WorkerBaseComponent;
+    use crate::workers::base::structs::QuoteParams;
+    use crate::workers::dvn::events::DstConfigSet;
+    use crate::workers::dvn::fee_lib::interface::{
+        FeeParams, IDvnFeeLibDispatcher, IDvnFeeLibDispatcherTrait,
+    };
+    use crate::workers::dvn::interface::IDvn;
+    use crate::workers::dvn::structs::{DstConfig, ExecuteParam, SetDstConfigParams};
+    use crate::workers::dvn::{errors, events};
+    use crate::workers::interface::ILayerZeroWorker;
+
+    ////////////////
+    // Components //
+    ////////////////
+
+    // Base worker component
+    component!(path: WorkerBaseComponent, storage: worker_base, event: WorkerBaseEvent);
+
+    // Access control components
+    component!(path: AccessControlComponent, storage: access_control, event: AccessControlEvent);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+
+    // Upgradeable component
+    component!(path: UpgradeableComponent, storage: upgradeable, event: UpgradeableEvent);
+
+    // Multisig component
+    component!(path: MultisigComponent, storage: multisig, event: MultisigEvent);
+
+    // Pausable component
+    component!(path: PausableComponent, storage: pausable, event: PausableEvent);
+
+    ////////////////
+    // Embeddings //
+    ////////////////
+
+    #[abi(embed_v0)]
+    impl WorkerBaseImpl = WorkerBaseComponent::WorkerBaseImpl<ContractState>;
+    impl WorkerBaseInternalImpl = WorkerBaseComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl MultisigImpl = MultisigComponent::Multisig<ContractState>;
+    impl MultisigInternalImpl = MultisigComponent::MultisigInternalImpl<ContractState>;
+
+    // Multisig immutable configuration
+    impl MultisigImmutableConfig of MultisigComponent::ImmutableConfig {
+        // TODO: this value should be set testing the gas limit on testnet
+        // with a value where you can re-set the threshold without hitting the gas limit
+        const MAX_THRESHOLD: u32 = 11;
+    }
+
+    #[abi(embed_v0)]
+    impl AccessControlImpl = WorkerBaseComponent::AccessControlImpl<ContractState>;
+    impl AccessControlInternalImpl = AccessControlComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl PausableImpl = PausableComponent::PausableImpl<ContractState>;
+
+    impl UpgradeableInternalImpl = UpgradeableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        worker_base: WorkerBaseComponent::Storage,
+        #[substorage(v0)]
+        access_control: AccessControlComponent::Storage,
+        #[substorage(v0)]
+        src5: SRC5Component::Storage,
+        #[substorage(v0)]
+        upgradeable: UpgradeableComponent::Storage,
+        #[substorage(v0)]
+        multisig: MultisigComponent::Storage,
+        #[substorage(v0)]
+        pausable: PausableComponent::Storage,
+        /// Eid => DstConfig
+        dst_configs: Map<u32, DstConfig>,
+        /// Verifier ID
+        vid: u32,
+        /// Record used hashes to prevent reentry and replay attack
+        used_hashes: Map<Bytes32, bool>,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        WorkerBaseEvent: WorkerBaseComponent::Event,
+        #[flat]
+        ReentrancyGuardEvent: ReentrancyGuardComponent::Event,
+        #[flat]
+        AccessControlEvent: AccessControlComponent::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event,
+        #[flat]
+        UpgradeableEvent: UpgradeableComponent::Event,
+        #[flat]
+        MultisigEvent: MultisigComponent::Event,
+        #[flat]
+        PausableEvent: PausableComponent::Event,
+        // DVN-specific events
+        DstConfigSet: DstConfigSet,
+        VerifySignaturesFailed: events::VerifySignaturesFailed,
+        HashAlreadyUsed: events::HashAlreadyUsed,
+        ExecuteFailed: events::ExecuteFailed,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        vid: u32,
+        message_libs: Array<ContractAddress>,
+        price_feed: ContractAddress,
+        default_multiplier_bps: u16,
+        multisig_signers: Span<EthAddress>,
+        multisig_threshold: u32,
+        role_admin: ContractAddress,
+        admins: Array<ContractAddress>,
+    ) {
+        // Initialize access control component
+        self.access_control.initializer();
+
+        // Initialize base worker & multisig components
+        self
+            .worker_base
+            .initializer(message_libs, price_feed, default_multiplier_bps, role_admin, admins);
+        self.multisig._init(multisig_signers, multisig_threshold);
+
+        // Set ID
+        self.vid.write(vid);
+    }
+
+    #[abi(embed_v0)]
+    impl DvnImpl of IDvn<ContractState> {
+        // ================================== Only Admin =====================================
+
+        fn set_dst_config(ref self: ContractState, params: Array<SetDstConfigParams>) {
+            self.worker_base._assert_only_admin();
+
+            let dst_config_set = params.span();
+            for param in params.into_iter() {
+                self.dst_configs.write(param.dst_eid, param.config);
+            }
+
+            self.emit(DstConfigSet { dst_config_set });
+        }
+
+        fn execute(ref self: ContractState, params: Array<ExecuteParam>) {
+            self.worker_base._assert_only_admin();
+
+            for (index, param) in params.into_iter().enumerate() {
+                let ExecuteParam { vid, call_data, expiration, signatures } = param.clone();
+
+                // Skip if invalid or expired
+                if vid != self.vid.read() || expiration <= get_block_timestamp().into() {
+                    continue;
+                }
+
+                // Verify signatures
+                let hash = self.hash_call_data(vid, call_data, expiration);
+                if let Err(error) = self
+                    .multisig
+                    ._verify_n_signatures(hash.into(), signatures, self.multisig.get_threshold()) {
+                    self.emit(events::VerifySignaturesFailed { error });
+                    continue;
+                }
+
+                // Skip if hash already used, register hash if not
+                if self.used_hashes.read(hash) {
+                    self.emit(events::HashAlreadyUsed { execute_param: param, hash });
+                    continue;
+                }
+                self.used_hashes.write(hash, true);
+
+                // Record used hash and execute syscall
+                let result = call_contract_syscall(
+                    call_data.to, call_data.selector, call_data.calldata,
+                );
+
+                if let Err(data) = result {
+                    // Un-use hash if syscall fails
+                    self.used_hashes.write(hash, false);
+                    self.emit(events::ExecuteFailed { index, data });
+                }
+            }
+        }
+
+        // ================================== Only Quorum =====================================
+
+        fn quorum_change_admin(ref self: ContractState, param: ExecuteParam) {
+            let ExecuteParam { vid, call_data, expiration, signatures } = param;
+
+            // Panic if expired
+            assert_with_byte_array(
+                expiration > get_block_timestamp().into(), errors::err_instruction_expired(),
+            );
+
+            // Panic if target is not the DVN
+            assert_with_byte_array(
+                call_data.to == get_contract_address(), errors::err_invalid_target(call_data.to),
+            );
+
+            // Panic if invalid VID
+            assert_with_byte_array(vid == self.vid.read(), errors::err_invalid_vid(vid));
+
+            // Verify signatures
+            let hash = self.hash_call_data(vid, call_data, expiration);
+            self.multisig.verify_signatures(hash.into(), signatures);
+
+            // Panic if hash already used
+            assert_with_byte_array(!self.used_hashes.read(hash), errors::err_duplicated_hash(hash));
+
+            // Record used hash
+            self.used_hashes.write(hash, true);
+
+            // Deserialize the new admin address from calldata & grant admin role or panic
+            let mut calldata = call_data.calldata;
+            let new_admin = Serde::deserialize(ref calldata);
+            assert_with_byte_array(new_admin.is_some(), errors::err_invalid_quorum_admin());
+            self.access_control._grant_role(ADMIN_ROLE, new_admin.unwrap());
+        }
+
+        // ================================== Only Self =====================================
+
+        fn upgrade(ref self: ContractState, new_class_hash: ClassHash) {
+            self.multisig._only_multisig();
+            self.upgradeable.upgrade(new_class_hash);
+        }
+
+        fn upgrade_and_call(
+            ref self: ContractState,
+            new_class_hash: ClassHash,
+            selector: felt252,
+            calldata: Span<felt252>,
+        ) -> Span<felt252> {
+            self.multisig._only_multisig();
+            self.upgradeable.upgrade_and_call(new_class_hash, selector, calldata)
+        }
+
+        // ================================== View ==========================================
+
+        fn get_dst_config(self: @ContractState, dst_eid: u32) -> DstConfig {
+            self.dst_configs.read(dst_eid)
+        }
+
+        fn hash_call_data(
+            self: @ContractState, vid: u32, call_data: Call, expiration: u256,
+        ) -> Bytes32 {
+            // encode and keccak: vid, to, selector, expiration, call_data
+            let mut payload: ByteArray = Default::default();
+
+            payload.append_u32(vid);
+            payload.append_address(call_data.to);
+            payload.append_u256(expiration);
+            payload.append_felt252(call_data.selector);
+
+            for i in call_data.calldata {
+                payload.append_felt252(*i);
+            }
+
+            keccak256(@payload)
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl LayerZeroWorkerImpl of ILayerZeroWorker<ContractState> {
+        // ================================== Only Message Lib =====================================
+
+        fn assign_job(ref self: ContractState, params: QuoteParams) -> u256 {
+            self.worker_base._assert_not_paused();
+            self.worker_base._assert_only_message_lib();
+            self.quote(params)
+        }
+
+        // ================================== View =====================================
+
+        fn quote(self: @ContractState, params: QuoteParams) -> u256 {
+            self.worker_base._assert_not_paused();
+
+            // Assert price feed is set
+            let price_feed = self.worker_base.get_price_feed();
+            assert_with_byte_array(price_feed.is_non_zero(), errors::err_price_feed_not_set());
+
+            // Assert worker fee lib is set
+            let worker_fee_lib_addr = self.worker_base.get_worker_fee_lib();
+            assert_with_byte_array(
+                worker_fee_lib_addr.is_non_zero(), errors::err_worker_fee_lib_not_set(),
+            );
+
+            let QuoteParams { dst_eid, confirmations, sender, options, .. } = params;
+
+            let fee_params = FeeParams {
+                price_feed,
+                dst_eid,
+                confirmations,
+                sender,
+                quorum: self.multisig.get_threshold(),
+                default_multiplier_bps: self.worker_base.get_default_multiplier_bps(),
+            };
+
+            // Call fee lib to get the quote
+            let fee_lib = IDvnFeeLibDispatcher { contract_address: worker_fee_lib_addr };
+            fee_lib.get_fee(fee_params, self.get_dst_config(dst_eid), options)
+        }
+    }
+}

package/layerzero/src/workers/dvn/errors.cairo

@@ -0,0 +1,80 @@
+//! DVN errors
+
+use lz_utils::bytes::Bytes32;
+use lz_utils::error::{Error, format_error};
+use starknet::ContractAddress;
+
+#[derive(Drop, Clone, Debug, PartialEq)]
+pub enum DvnError {
+    InvalidDvnIdx,
+    InvalidDVNOptions,
+    EidNotSupported,
+    PriceFeedNotSet,
+    WorkerFeeLibNotSet,
+    InstructionExpired,
+    InvalidVid,
+    InvalidTarget,
+    InvalidQuorumAdmin,
+    DuplicatedHash,
+}
+
+impl DvnErrorImpl of Error<DvnError> {
+    fn prefix() -> ByteArray {
+        "LZ_DVN"
+    }
+
+    fn name(self: DvnError) -> ByteArray {
+        match self {
+            DvnError::InvalidDvnIdx => "INVALID_DVN_IDX",
+            DvnError::InvalidDVNOptions => "INVALID_DVN_OPTIONS",
+            DvnError::EidNotSupported => "EID_NOT_SUPPORTED",
+            DvnError::PriceFeedNotSet => "PRICE_FEED_NOT_SET",
+            DvnError::WorkerFeeLibNotSet => "WORKER_FEELIB_NOT_SET",
+            DvnError::InstructionExpired => "INSTRUCTION_EXPIRED",
+            DvnError::InvalidVid => "INVALID_VID",
+            DvnError::InvalidTarget => "INVALID_TARGET",
+            DvnError::InvalidQuorumAdmin => "INVALID_QUORUM_ADMIN",
+            DvnError::DuplicatedHash => "DUPLICATED_HASH",
+        }
+    }
+}
+
+pub fn err_invalid_dvn_idx() -> ByteArray {
+    format_error(DvnError::InvalidDvnIdx, "")
+}
+
+pub fn err_invalid_dvn_options(cursor: usize) -> ByteArray {
+    format_error(DvnError::InvalidDVNOptions, format!("cursor: {}", cursor))
+}
+
+pub fn err_eid_not_supported(eid: u32) -> ByteArray {
+    format_error(DvnError::EidNotSupported, format!("eid: {}", eid))
+}
+
+pub fn err_price_feed_not_set() -> ByteArray {
+    format_error(DvnError::PriceFeedNotSet, "")
+}
+
+pub fn err_worker_fee_lib_not_set() -> ByteArray {
+    format_error(DvnError::WorkerFeeLibNotSet, "")
+}
+
+pub fn err_instruction_expired() -> ByteArray {
+    format_error(DvnError::InstructionExpired, "")
+}
+
+pub fn err_invalid_vid(vid: u32) -> ByteArray {
+    format_error(DvnError::InvalidVid, format!("vid: {}", vid))
+}
+
+pub fn err_invalid_target(target: ContractAddress) -> ByteArray {
+    format_error(DvnError::InvalidTarget, format!("target: {:?}", target))
+}
+
+pub fn err_invalid_quorum_admin() -> ByteArray {
+    format_error(DvnError::InvalidQuorumAdmin, "")
+}
+
+pub fn err_duplicated_hash(hash: Bytes32) -> ByteArray {
+    format_error(DvnError::DuplicatedHash, format!("hash: {:?}", hash))
+}

package/layerzero/src/workers/dvn/events.cairo

@@ -0,0 +1,30 @@
+//! DVN events
+
+use lz_utils::bytes::Bytes32;
+use crate::workers::dvn::structs::{ExecuteParam, SetDstConfigParams};
+
+/// Event emitted when the destination config is set
+#[derive(Drop, starknet::Event)]
+pub struct DstConfigSet {
+    pub dst_config_set: Span<SetDstConfigParams>,
+}
+
+/// Event emitted when the signatures are not valid
+#[derive(Drop, starknet::Event)]
+pub struct VerifySignaturesFailed {
+    pub error: ByteArray,
+}
+
+/// Event emitted when the hash is already used
+#[derive(Drop, starknet::Event)]
+pub struct HashAlreadyUsed {
+    pub execute_param: ExecuteParam,
+    pub hash: Bytes32,
+}
+
+/// Event emitted when the execute call fails
+#[derive(Drop, starknet::Event)]
+pub struct ExecuteFailed {
+    pub index: u32,
+    pub data: Array<felt252>,
+}