@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.11

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

@@ -1,24 +1,22 @@
 #![no_std]
-#[cfg(test)]
-extern crate std;
 
-mod errors;
+pub mod errors;
 pub mod events;
-mod interfaces;
-mod types;
+pub mod interfaces;
 
-pub use errors::*;
 pub use interfaces::*;
-pub use types::*;
 
 cfg_if::cfg_if! {
     if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
         mod storage;
         mod dvn;
 
-        pub use dvn::Dvn;
+        pub use dvn::*;
     }
 }
 
+#[cfg(test)]
+extern crate std;
+
 #[cfg(test)]
 mod tests;

package/contracts/workers/dvn/src/multisig.rs

@@ -1,10 +1,13 @@
+use super::*;
+
 use crate::{
+    errors::MultisigError,
     events::{SignerSet, ThresholdSet},
     storage::MultisigStorage,
-    IMultisig,
 };
+use soroban_sdk::assert_with_error;
 
-#[contractimpl]
+#[contract_impl]
 impl IMultisig for Dvn {
     fn set_signer(env: &Env, signer: &BytesN<20>, active: bool) {
         env.current_contract_address().require_auth();
@@ -109,7 +112,7 @@ fn set_threshold(env: &Env, threshold: u32) {
     ThresholdSet { threshold }.publish(env);
 }
 
-fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
+pub fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
     signers.iter().for_each(|signer| add_signer(env, &signer));
 
     set_threshold(env, threshold);

package/contracts/workers/dvn/src/tests/auth.rs

@@ -1,5 +1,5 @@
 use crate::tests::setup::{TestSetup, VID};
-use crate::{errors::DvnError, errors::MultisigError, TransactionAuthData};
+use crate::{dvn::auth::TransactionAuthData, errors::DvnError, errors::MultisigError};
 use ed25519_dalek::{Signer, SigningKey};
 use rand::thread_rng;
 use soroban_sdk::{auth::Context, vec, Bytes, BytesN, Env, IntoVal, Vec};

package/contracts/workers/dvn/src/tests/dvn.rs

@@ -52,11 +52,10 @@ fn test_vid_returns_configured_value() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #5)")] // DvnError::EidNotSupported
-fn test_dst_config_not_set_panics() {
+fn test_dst_config_not_set_returns_none() {
     let setup = TestSetup::new(1);
     let client = DVNClient::new(&setup.env, &setup.contract_id);
-    client.dst_config(&999);
+    assert_eq!(client.dst_config(&999), None);
 }
 
 #[test]
@@ -339,7 +338,7 @@ struct MockFeeLib;
 
 #[contractimpl]
 impl IDvnFeeLib for MockFeeLib {
-    fn get_fee(_env: &Env, params: &DvnFeeParams) -> i128 {
+    fn get_fee(_env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
         if params.multiplier_bps == 0 {
             params.default_multiplier_bps as i128
         } else {

package/contracts/workers/dvn-fee-lib/Cargo.toml

@@ -16,9 +16,10 @@ doctest = false
 [dependencies]
 cfg-if = "1.0"
 soroban-sdk = { workspace = true }
+common-macros = { workspace = true }
 message-lib-common = { workspace = true }
+utils = { workspace = true }
 worker = { workspace = true }
-common-macros = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }

package/contracts/workers/dvn-fee-lib/src/dvn_fee_lib.rs

@@ -1,5 +1,6 @@
 use crate::DvnFeeLibError;
-use soroban_sdk::{assert_with_error, contract, contractimpl, Env};
+use common_macros::contract_impl;
+use soroban_sdk::{assert_with_error, contract, Address, Env};
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
@@ -29,9 +30,9 @@ pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 #[contract]
 pub struct DvnFeeLib;
 
-#[contractimpl]
+#[contract_impl]
 impl IDvnFeeLib for DvnFeeLib {
-    fn get_fee(env: &Env, params: &DvnFeeParams) -> i128 {
+    fn get_fee(env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
         assert_with_error!(env, params.gas > 0, DvnFeeLibError::InvalidGas);
         assert_with_error!(env, params.options.is_empty(), DvnFeeLibError::InvalidDVNOptions);
 

package/contracts/workers/dvn-fee-lib/src/tests/dvn_fee_lib.rs

@@ -77,6 +77,7 @@ fn apply_premium_multiplier_wins_over_small_floor() {
 fn get_fee_panics_when_gas_zero() {
     let env = Env::default();
     env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
     let params = DvnFeeParams {
         sender: Address::generate(&env),
         dst_eid: 1,
@@ -90,7 +91,7 @@ fn get_fee_panics_when_gas_zero() {
         floor_margin_usd: 0,
     };
 
-    DvnFeeLib::get_fee(&env, &params);
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[test]
@@ -98,6 +99,7 @@ fn get_fee_panics_when_gas_zero() {
 fn get_fee_panics_when_options_not_empty() {
     let env = Env::default();
     env.mock_all_auths();
+    let fee_lib_addr = env.register(DvnFeeLib, ());
     let mut options = Bytes::new(&env);
     options.push_back(1u8);
 
@@ -114,7 +116,7 @@ fn get_fee_panics_when_options_not_empty() {
         floor_margin_usd: 0,
     };
 
-    DvnFeeLib::get_fee(&env, &params);
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[contract]
@@ -183,7 +185,7 @@ fn get_fee_success_path() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 100);
 }
@@ -209,7 +211,7 @@ fn get_fee_uses_default_multiplier_when_zero() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 120);
 }
@@ -235,7 +237,7 @@ fn get_fee_prefers_dst_multiplier_over_default() {
         floor_margin_usd: 0,
     };
 
-    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    let fee = env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 
     assert_eq!(fee, 150);
 }
@@ -259,7 +261,7 @@ fn get_fee_panics_when_price_feed_returns_negative_fee() {
         floor_margin_usd: 0,
     };
 
-    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &params));
+    env.as_contract(&fee_lib_addr, || DvnFeeLib::get_fee(&env, &fee_lib_addr, &params));
 }
 
 #[test]

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/lz_executor.rs

@@ -19,8 +19,8 @@ use soroban_sdk::{
 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.
@@ -140,8 +140,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 +219,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,
@@ -304,5 +304,5 @@ impl LzExecutor {
     }
 }
 
-#[contractimpl(contracttrait)]
+#[contract_impl(contracttrait)]
 impl Worker for LzExecutor {}

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 },
+}