@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.12

package/contracts/workers/executor/src/events.rs

@@ -1,15 +1,16 @@
-use common_macros::event;
 use endpoint_v2::Origin;
-use soroban_sdk::{Address, Vec};
+use soroban_sdk::{contractevent, Address, Vec};
 
 use crate::interfaces::{NativeDropParams, SetDstConfigParam};
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DstConfigSet {
     pub params: Vec<SetDstConfigParam>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct NativeDropApplied {
     pub origin: Origin,
     pub dst_eid: u32,

package/contracts/workers/executor/src/{lz_executor.rs → executor.rs}

@@ -8,44 +8,14 @@ use crate::{
 use common_macros::{contract_impl, only_owner, ttl_configurable};
 use endpoint_v2::{FeeRecipient, LayerZeroEndpointV2Client, Origin};
 use message_lib_common::interfaces::ILayerZeroExecutor;
-use soroban_sdk::{
-    address_payload::AddressPayload,
-    auth::{Context, CustomAccountInterface},
-    contract, contractimpl, contracttype,
-    crypto::Hash,
-    token::TokenClient,
-    vec, Address, Bytes, BytesN, Env, Symbol, Vec,
-};
+use soroban_sdk::{contract, token::TokenClient, vec, Address, Bytes, BytesN, Env, Symbol, Vec};
 use utils::option_ext::OptionExt;
 use utils::ownable::Ownable;
 use worker::{
-    assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, ExecutorFeeLibClient,
-    FeeParams, Worker, set_admin_by_owner,
+    assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, set_admin_by_owner,
+    ExecutorFeeLibClient, FeeParams, Worker,
 };
 
-/// Signature data for Custom Account authorization.
-/// Contains the admin's public key and their Ed25519 signature over the authorization payload.
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ExecutorSignature {
-    /// Admin's Ed25519 public key (32 bytes) - must correspond to a registered admin
-    pub public_key: BytesN<32>,
-    /// Ed25519 signature (64 bytes) over the signature_payload
-    pub signature: BytesN<64>,
-}
-
-/// Whitelist entry for authorized (contract, function) pairs.
-///
-/// Used to configure which contracts and functions can trigger Executor authorization.
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct WhitelistEntry {
-    /// Contract address that is allowed to call the function.
-    pub contract: Address,
-    /// Function name that is whitelisted for this contract.
-    pub fn_name: Symbol,
-}
-
 /// LayerZero Executor contract for cross-chain message execution.
 #[contract]
 #[ttl_configurable]
@@ -65,6 +35,8 @@ impl LzExecutor {
     /// * `price_feed` - Price feed contract address for fee calculations
     /// * `default_multiplier_bps` - Default fee multiplier in basis points (10000 = 1x)
     /// * `whitelist` - Initial whitelisted (contract, function) pairs for authorization
+    /// * `worker_fee_lib` - Worker fee library contract address
+    /// * `deposit_address` - Address to receive fee payments
     pub fn __constructor(
         env: &Env,
         endpoint: &Address,
@@ -73,15 +45,25 @@ impl LzExecutor {
         message_libs: &Vec<Address>,
         price_feed: &Address,
         default_multiplier_bps: u32,
-        whitelist: &Vec<WhitelistEntry>,
+        whitelist: &Vec<(Address, Symbol)>,
+        worker_fee_lib: &Address,
+        deposit_address: &Address,
     ) {
         Self::init_owner(env, owner);
-        init_worker::<Self>(env, admins, message_libs, price_feed, default_multiplier_bps);
+        init_worker::<Self>(
+            env,
+            admins,
+            message_libs,
+            price_feed,
+            default_multiplier_bps,
+            worker_fee_lib,
+            deposit_address,
+        );
         ExecutorStorage::set_endpoint(env, endpoint);
 
         // Set initial whitelisted functions
-        for entry in whitelist.iter() {
-            ExecutorStorage::set_whitelisted_fn(env, &entry.contract, &entry.fn_name, &true);
+        for (contract, fn_name) in whitelist.iter() {
+            ExecutorStorage::set_whitelisted_fn(env, &contract, &fn_name, &true);
         }
     }
 
@@ -140,8 +122,8 @@ impl IExecutor for LzExecutor {
     }
 
     /// Returns the destination configuration for a specific endpoint.
-    fn dst_config(env: &Env, dst_eid: u32) -> DstConfig {
-        ExecutorStorage::dst_config(env, dst_eid).unwrap_or_panic(env, ExecutorError::EidNotSupported)
+    fn dst_config(env: &Env, dst_eid: u32) -> Option<DstConfig> {
+        ExecutorStorage::dst_config(env, dst_eid)
     }
 
     /// Native token drops.
@@ -219,7 +201,7 @@ impl ILayerZeroExecutor for LzExecutor {
         assert_not_paused::<Self>(env);
         assert_acl::<Self>(env, sender);
 
-        let dst_config = Self::dst_config(env, dst_eid);
+        let dst_config = Self::dst_config(env, dst_eid).unwrap_or_panic(env, ExecutorError::EidNotSupported);
         let fee_params = FeeParams {
             sender: sender.clone(),
             dst_eid,
@@ -239,70 +221,15 @@ impl ILayerZeroExecutor for LzExecutor {
 }
 
 // ============================================================================
-// CustomAccountInterface implementation, used for receive-flow execution
+// Worker Implementation
 // ============================================================================
 
-#[contractimpl]
-impl CustomAccountInterface for LzExecutor {
-    type Signature = ExecutorSignature;
-    type Error = ExecutorError;
-
-    /// Verifies authorization for the executor contract.
-    ///
-    /// The public key must correspond to a registered admin and must have signed the signature_payload.
-    /// Uses Ed25519 signature verification.
-    /// Only whitelisted function calls are authorized.
-    fn __check_auth(
-        env: Env,
-        signature_payload: Hash<32>,
-        auth_data: Self::Signature,
-        auth_contexts: Vec<Context>,
-    ) -> Result<(), Self::Error> {
-        Self::verify_admin_signature(&env, &signature_payload, &auth_data)?;
-        Self::validate_auth_contexts(&env, &auth_contexts)?;
-        Ok(())
-    }
-}
-
-impl LzExecutor {
-    /// Verifies that the signature is from a registered admin.
-    ///
-    /// Converts the public key to an address, checks admin registration,
-    /// and verifies the Ed25519 signature over the payload.
-    fn verify_admin_signature(
-        env: &Env,
-        signature_payload: &Hash<32>,
-        auth_data: &ExecutorSignature,
-    ) -> Result<(), ExecutorError> {
-        let admin = Address::from_payload(env, AddressPayload::AccountIdPublicKeyEd25519(auth_data.public_key.clone()));
-        if !Self::is_admin(env, &admin) {
-            return Err(ExecutorError::Unauthorized);
-        }
-        env.crypto().ed25519_verify(&auth_data.public_key, &signature_payload.clone().into(), &auth_data.signature);
-        Ok(())
-    }
-
-    /// Validates that the first auth context is a whitelisted (contract, function) pair.
-    /// Sub-invocations are trusted since they're controlled by the whitelisted contract.
-    fn validate_auth_contexts(env: &Env, contexts: &Vec<Context>) -> Result<(), ExecutorError> {
-        let first_context = contexts.first().ok_or(ExecutorError::UnauthorizedContext)?;
-
-        match first_context {
-            Context::Contract(contract_context) => {
-                // Check if (contract, fn_name) pair is whitelisted
-                if !Self::is_whitelisted_fn(env, &contract_context.contract, &contract_context.fn_name) {
-                    return Err(ExecutorError::UnauthorizedContext);
-                }
-            }
-            // Contract creation is not allowed
-            Context::CreateContractHostFn(_) | Context::CreateContractWithCtorHostFn(_) => {
-                return Err(ExecutorError::UnauthorizedContext);
-            }
-        }
+#[contract_impl(contracttrait)]
+impl Worker for LzExecutor {}
 
-        Ok(())
-    }
-}
+// ============================================================================
+// Include SubModules
+// ============================================================================
 
-#[contractimpl(contracttrait)]
-impl Worker for LzExecutor {}
+#[path = "auth.rs"]
+pub mod auth;

package/contracts/workers/executor/src/interfaces/executor.rs

@@ -59,11 +59,14 @@ pub trait IExecutor: Worker + ILayerZeroExecutor {
     /// * `params` - Vector of (dst_eid, DstConfig) pairs to set
     fn set_dst_config(env: &Env, admin: &Address, params: &Vec<SetDstConfigParam>);
 
-    /// Returns the destination configuration for a specific endpoint.
+    /// Gets the destination configuration for a specific endpoint.
     ///
     /// # Arguments
     /// * `dst_eid` - Destination endpoint ID (chain identifier)
-    fn dst_config(env: &Env, dst_eid: u32) -> DstConfig;
+    ///
+    /// # Returns
+    /// The destination configuration, or `None` if not set
+    fn dst_config(env: &Env, dst_eid: u32) -> Option<DstConfig>;
 
     /// Native token drops.
     ///

package/contracts/workers/executor/src/interfaces/mod.rs

@@ -1,3 +1,3 @@
-pub mod executor;
+mod executor;
 
 pub use executor::*;

package/contracts/workers/executor/src/lib.rs

@@ -1,17 +1,18 @@
 #![no_std]
 
-mod interfaces;
+pub mod errors;
+pub mod events;
+pub mod interfaces;
+
 pub use interfaces::*;
 
 cfg_if::cfg_if! {
     // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
     if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
-        mod errors;
-        mod events;
         mod storage;
-        mod lz_executor;
+        mod executor;
 
-        pub use lz_executor::{LzExecutor, LzExecutorClient, WhitelistEntry};
+        pub use executor::*;
     }
 }
 

package/contracts/workers/price-feed/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "price-feed"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+utils = { workspace = true }
+worker = { workspace = true }
+common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+

package/contracts/workers/price-feed/src/errors.rs

@@ -0,0 +1,9 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum PriceFeedError {
+    OnlyPriceUpdater,
+    InvalidDenominator,
+    NotAnOpStack,
+    NoPrice,
+}

package/contracts/workers/price-feed/src/events.rs

@@ -0,0 +1,30 @@
+use soroban_sdk::{contractevent, Address};
+
+use worker::Price;
+
+use crate::types::ArbitrumPriceExt;
+
+// ============================================================================
+// Price Feed Events
+// ============================================================================
+
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PriceUpdaterSet {
+    pub updater: Address,
+    pub active: bool,
+}
+
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PriceUpdated {
+    pub dst_eid: u32,
+    pub price: Price,
+}
+
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ArbitrumPriceExtUpdated {
+    pub dst_eid: u32,
+    pub arbitrum_price_ext: ArbitrumPriceExt,
+}

package/contracts/workers/price-feed/src/lib.rs

@@ -0,0 +1,11 @@
+#![no_std]
+
+mod errors;
+mod events;
+mod price_feed;
+mod storage;
+mod types;
+
+pub use errors::*;
+pub use price_feed::{LzPriceFeed, LzPriceFeedClient};
+pub use types::*;

package/contracts/workers/price-feed/src/price_feed.rs

@@ -0,0 +1,265 @@
+use common_macros::{only_owner, ttl_configurable};
+use soroban_sdk::{assert_with_error, contract, contractimpl, panic_with_error, Address, Env, Vec};
+use utils::ownable::Ownable;
+use worker::{FeeEstimate, ILayerZeroPriceFeed, Price};
+
+use crate::{
+    errors::PriceFeedError,
+    events::{ArbitrumPriceExtUpdated, PriceUpdated, PriceUpdaterSet},
+    storage::PriceFeedStorage,
+    types::{ArbitrumPriceExt, ModelType, SetEidToModelTypeParam, UpdatePrice, UpdatePriceExt},
+};
+
+#[contract]
+#[ttl_configurable]
+pub struct LzPriceFeed;
+
+#[contractimpl]
+impl LzPriceFeed {
+    pub fn __constructor(env: &Env, owner: &Address, price_updater: &Address) {
+        Self::init_owner(env, owner);
+
+        PriceFeedStorage::set_price_updater(env, price_updater, &true);
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroPriceFeed for LzPriceFeed {
+    /// Estimate fee with detailed breakdown by endpoint ID
+    /// Corresponds to estimateFeeByEid in PriceFeed.sol
+    fn estimate_fee_by_eid(env: &Env, fee_lib: &Address, dst_eid: u32, calldata_size: u32, gas: u128) -> FeeEstimate {
+        fee_lib.require_auth();
+
+        let eid = dst_eid % 30_000;
+
+        let (fee, price_ratio) = if eid == 110 || eid == 10143 || eid == 20143 {
+            Self::estimate_fee_with_arbitrum_model(env, eid, calldata_size, gas)
+        } else if eid == 111 || eid == 10132 || eid == 20132 {
+            Self::estimate_fee_with_optimism_model(env, eid, calldata_size, gas)
+        } else {
+            // Check configured model type
+            let model_type = Self::eid_to_model_type(env, eid);
+            match model_type {
+                ModelType::OpStack => Self::estimate_fee_with_optimism_model(env, eid, calldata_size, gas),
+                ModelType::ArbStack => Self::estimate_fee_with_arbitrum_model(env, eid, calldata_size, gas),
+                ModelType::Default => Self::estimate_fee_with_default_model(env, eid, calldata_size, gas),
+            }
+        };
+
+        let price_ratio_denominator = Self::get_price_ratio_denominator(env);
+        let native_price_usd = Self::native_token_price_usd(env);
+
+        FeeEstimate { total_gas_fee: fee as i128, price_ratio, price_ratio_denominator, native_price_usd }
+    }
+
+    /// Get the native token price in USD
+    fn native_token_price_usd(env: &Env) -> u128 {
+        PriceFeedStorage::native_price_usd(env)
+    }
+
+    /// Get the price for a destination EID.
+    fn get_price(env: &Env, dst_eid: u32) -> Price {
+        PriceFeedStorage::default_model_price(env, dst_eid)
+            .unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice))
+    }
+
+    /// Get the price ratio denominator.
+    fn get_price_ratio_denominator(env: &Env) -> u128 {
+        PriceFeedStorage::price_ratio_denominator(env)
+    }
+}
+
+#[contractimpl]
+impl LzPriceFeed {
+    // ========================================================================
+    // Owner Functions
+    // ========================================================================
+
+    /// Set price updater status (owner only)
+    #[only_owner]
+    pub fn set_price_updater(env: &Env, updater: &Address, active: bool) {
+        PriceFeedStorage::set_price_updater(env, updater, &active);
+        PriceUpdaterSet { updater: updater.clone(), active }.publish(env);
+    }
+
+    /// Set the price ratio denominator (owner only)
+    #[only_owner]
+    pub fn set_price_ratio_denominator(env: &Env, denominator: u128) {
+        assert_with_error!(env, denominator > 0, PriceFeedError::InvalidDenominator);
+        PriceFeedStorage::set_price_ratio_denominator(env, &denominator);
+    }
+
+    /// Set the Arbitrum compression percentage (owner only)
+    #[only_owner]
+    pub fn set_arbitrum_compression_percent(env: &Env, compression_percent: u128) {
+        PriceFeedStorage::set_arbitrum_compression_percent(env, &compression_percent);
+    }
+
+    /// Set the fee model type for destination EIDs (owner only)
+    #[only_owner]
+    pub fn set_eid_to_model_type(env: &Env, params: &Vec<SetEidToModelTypeParam>) {
+        for param in params.iter() {
+            PriceFeedStorage::set_eid_to_model_type(env, param.dst_eid, &param.model_type);
+        }
+    }
+
+    // ========================================================================
+    // Price Updater Functions
+    // ========================================================================
+
+    /// Set prices for multiple destinations (price updater or owner)
+    pub fn set_price(env: &Env, price_updater: &Address, prices: &Vec<UpdatePrice>) {
+        Self::require_price_updater(env, price_updater);
+
+        for update in prices.iter() {
+            Self::set_price_internal(env, update.eid, &update.price);
+        }
+    }
+
+    /// Set price for Arbitrum with extension (price updater or owner)
+    /// Corresponds to setPriceForArbitrum in PriceFeed.sol
+    pub fn set_price_for_arbitrum(env: &Env, price_updater: &Address, update: &UpdatePriceExt) {
+        Self::require_price_updater(env, price_updater);
+
+        Self::set_price_internal(env, update.eid, &update.price);
+
+        // Update Arbitrum-specific price extension
+        PriceFeedStorage::set_arbitrum_price_ext(env, &update.extend);
+        ArbitrumPriceExtUpdated { dst_eid: update.eid, arbitrum_price_ext: update.extend.clone() }.publish(env);
+    }
+
+    /// Set the native token price in USD (price updater or owner).
+    ///
+    /// Kept as a standalone contract function (not part of the canonical `worker::ILayerZeroPriceFeed` interface).
+    pub fn set_native_token_price_usd(env: &Env, price_updater: &Address, native_token_price_usd: u128) {
+        Self::require_price_updater(env, price_updater);
+        PriceFeedStorage::set_native_price_usd(env, &native_token_price_usd);
+    }
+
+    // ========================================================================
+    // View Functions
+    // ========================================================================
+
+    /// Check if an address is an active price updater
+    pub fn price_updater(env: &Env, updater: &Address) -> bool {
+        PriceFeedStorage::price_updater(env, updater)
+    }
+
+    /// Get the Arbitrum compression percent
+    pub fn arbitrum_compression_percent(env: &Env) -> u128 {
+        PriceFeedStorage::arbitrum_compression_percent(env)
+    }
+
+    /// Get the Arbitrum price extension
+    pub fn arbitrum_price_ext(env: &Env) -> ArbitrumPriceExt {
+        PriceFeedStorage::arbitrum_price_ext(env)
+    }
+
+    /// Get the model type for a destination EID
+    pub fn eid_to_model_type(env: &Env, dst_eid: u32) -> ModelType {
+        PriceFeedStorage::eid_to_model_type(env, dst_eid)
+    }
+
+    // ========================================================================
+    // Internal Helper Functions
+    // ========================================================================
+
+    /// Set price for a destination EID
+    fn set_price_internal(env: &Env, dst_eid: u32, price: &Price) {
+        PriceFeedStorage::set_default_model_price(env, dst_eid, price);
+        PriceUpdated { dst_eid, price: price.clone() }.publish(env);
+    }
+
+    /// Estimate fee with default model
+    fn estimate_fee_with_default_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
+        let price = Self::get_price(env, dst_eid);
+
+        // assuming the _gas includes (1) the 21,000 overhead and (2) not the calldata gas
+        let gas_for_calldata = (calldata_size as u128) * (price.gas_per_byte as u128);
+        let remote_fee = (gas_for_calldata + gas) * (price.gas_price_in_unit as u128);
+        let fee = (remote_fee * price.price_ratio) / Self::get_price_ratio_denominator(env);
+
+        (fee, price.price_ratio)
+    }
+
+    /// Estimate fee with Optimism model
+    fn estimate_fee_with_optimism_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
+        let ethereum_id = Self::get_l1_lookup_id_for_optimism_model(env, dst_eid);
+
+        // L1 fee (Ethereum)
+        let ethereum_price = Self::get_price(env, ethereum_id);
+        let gas_for_l1_calldata = ((calldata_size as u128) * (ethereum_price.gas_per_byte as u128)) + 3188; // 2100 + 68 * 16
+        let l1_fee = gas_for_l1_calldata * (ethereum_price.gas_price_in_unit as u128);
+
+        // L2 fee (Optimism)
+        let optimism_price = Self::get_price(env, dst_eid);
+        let gas_for_l2_calldata: u128 = (calldata_size as u128) * (optimism_price.gas_per_byte as u128);
+        let l2_fee = (gas_for_l2_calldata + gas) * (optimism_price.gas_price_in_unit as u128);
+
+        let price_ratio_denom = Self::get_price_ratio_denominator(env);
+        let l1_fee_in_src_price = (l1_fee * ethereum_price.price_ratio) / price_ratio_denom;
+        let l2_fee_in_src_price = (l2_fee * optimism_price.price_ratio) / price_ratio_denom;
+        let gas_fee = l1_fee_in_src_price + l2_fee_in_src_price;
+
+        (gas_fee, optimism_price.price_ratio)
+    }
+
+    /// Estimate fee with Arbitrum model
+    fn estimate_fee_with_arbitrum_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
+        let arbitrum_price = Self::get_price(env, dst_eid);
+
+        let arbitrum_price_ext = Self::arbitrum_price_ext(env);
+
+        // L1 fee (compressed calldata)
+        let gas_for_l1_calldata = (((calldata_size as u128) * Self::arbitrum_compression_percent(env)) / 100)
+            * (arbitrum_price_ext.gas_per_l1_calldata_byte as u128);
+
+        // L2 fee
+        let gas_for_l2_calldata = (calldata_size as u128) * (arbitrum_price.gas_per_byte as u128);
+        let gas_fee = (gas + (arbitrum_price_ext.gas_per_l2_tx as u128) + gas_for_l1_calldata + gas_for_l2_calldata)
+            * (arbitrum_price.gas_price_in_unit as u128);
+
+        let fee = (gas_fee * arbitrum_price.price_ratio) / Self::get_price_ratio_denominator(env);
+
+        (fee, arbitrum_price.price_ratio)
+    }
+
+    /// Get L1 lookup ID for Optimism model
+    fn get_l1_lookup_id_for_optimism_model(env: &Env, l2_eid: u32) -> u32 {
+        let eid = l2_eid % 30_000;
+
+        if eid == 111 {
+            return 101;
+        } else if eid == 10132 {
+            return 10121; // Ethereum Goerli
+        } else if eid == 20132 {
+            return 20121; // Ethereum Goerli
+        }
+
+        // Check if this EID is configured as OP_STACK model type
+        assert_with_error!(env, Self::eid_to_model_type(env, eid) == ModelType::OpStack, PriceFeedError::NotAnOpStack);
+
+        if eid < 10000 {
+            101
+        } else if eid < 20000 {
+            10161 // Ethereum Sepolia
+        } else {
+            20121 // Ethereum Goerli
+        }
+    }
+
+    /// Check if caller is price updater or owner
+    fn require_price_updater(env: &Env, caller: &Address) {
+        caller.require_auth();
+
+        // Owner is always approved
+        if let Some(owner) = Self::owner(env) {
+            if &owner == caller {
+                return;
+            }
+        }
+
+        // Check if caller is an active price updater
+        assert_with_error!(env, Self::price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+    }
+}

package/contracts/workers/price-feed/src/storage.rs

@@ -0,0 +1,42 @@
+use common_macros::storage;
+use soroban_sdk::Address;
+use worker::Price;
+
+use crate::types::{ArbitrumPriceExt, ModelType};
+
+#[storage()]
+pub enum PriceFeedStorage {
+    /// Price ratio denominator used for price calculations (initialized to 1e20)
+    #[instance(u128)]
+    #[default(10u128.pow(20))]
+    PriceRatioDenominator,
+
+    /// Price updater status mapping (address => bool active)
+    #[persistent(bool)]
+    #[default(false)]
+    PriceUpdater { updater: Address },
+
+    /// Default price model for each destination EID
+    #[persistent(Price)]
+    DefaultModelPrice { dst_eid: u32 },
+
+    /// Arbitrum-specific price extension
+    #[instance(ArbitrumPriceExt)]
+    #[default(ArbitrumPriceExt { gas_per_l2_tx: 0, gas_per_l1_calldata_byte: 0 })]
+    ArbitrumPriceExt,
+
+    /// Native token price in USD (uses PRICE_RATIO_DENOMINATOR)
+    #[instance(u128)]
+    #[default(0)]
+    NativePriceUSD,
+
+    /// Arbitrum compression percentage (initialized to 47)
+    #[instance(u128)]
+    #[default(47)]
+    ArbitrumCompressionPercent,
+
+    /// Fee model type for each destination EID
+    #[persistent(ModelType)]
+    #[default(ModelType::Default)]
+    EidToModelType { dst_eid: u32 },
+}