Enhance dynamic gas price configuration and querying support for Cosmos EVM, Osmosis, and SkipFeeMarket

Author: allthatjazzleo

config.toml

@@ -311,14 +311,24 @@ gas_multiplier = 1.1
 # Query the current gas price from the chain instead of using the static `gas_price` from the config.
 # Useful for chains which have [EIP-1559][eip]-like dynamic gas price. 
 #
-# At the moment, only chains which support the `osmosis.txfees.v1beta1.Query/GetEipBaseFee`
-# query or have enabled Skip's `x/feemarket` module https://github.com/skip-mev/feemarket
+# At the moment, only chains which support the `/cosmos.evm.feemarket.v1.Query/BaseFee` query or
+# `osmosis.txfees.v1beta1.Query/GetEipBaseFee` query or have enabled Skip's `x/feemarket` module https://github.com/skip-mev/feemarket
 # can be used with dynamic gas price enabled.
 #
+# The `type` field allows you to specify which query method to use:
+# - `skip_fee_market`: Use Skip's feemarket module query at `/feemarket.feemarket.v1.Query/GasPrices`
+# - `osmosis`: Use Osmosis EIP-1559 query at `/osmosis.txfees.v1beta1.Query/GetEipBaseFee`
+# - `cosmos_evm`: Use Cosmos EVM query at `/cosmos.evm.feemarket.v1.Query/BaseFee`
+#
+# If `type` is not specified, Hermes will attempt to auto-detect for backwards compatibility:
+# - Chains starting with "osmosis" or "osmo-test" will use `osmosis` type
+# - All other chains will default to `skip_fee_market` type
+#
 # See this page in the Hermes guide for more information:
 # https://hermes.informal.systems/documentation/configuration/dynamic-gas-fees.html
 # 
 # Default: { enabled = false, multiplier = 1.1, max = 0.6 }
+# Example with type specified: { enabled = true, multiplier = 1.1, max = 0.6, type = 'cosmos_evm' }
 dynamic_gas_price = { enabled = false, multiplier = 1.1, max = 0.6 }
 
 # Specify how many IBC messages at most to include in a single transaction.

crates/relayer/src/chain/cosmos/eip_base_fee.rs

@@ -10,31 +10,29 @@ use tracing::{debug, trace};
 use ibc_proto::cosmos::base::v1beta1::{DecCoin, DecProto};
 use ibc_relayer_types::core::ics24_host::identifier::ChainId;
 
-use crate::error::Error;
+use crate::{config::dynamic_gas::DynamicGasType, error::Error};
 
 pub async fn query_eip_base_fee(
     rpc_address: &Url,
     gas_price_denom: &str,
+    dynamic_gas_type: &Option<DynamicGasType>,
     chain_id: &ChainId,
 ) -> Result<f64, Error> {
-    debug!("Querying Omosis EIP-1559 base fee from {rpc_address}");
-
-    let chain_name = chain_id.name();
-
-    let is_osmosis = chain_name.starts_with("osmosis") || chain_name.starts_with("osmo-test");
-
-    let url = if is_osmosis {
-        format!(
-            "{}abci_query?path=\"/osmosis.txfees.v1beta1.Query/GetEipBaseFee\"",
-            rpc_address
-        )
-    } else {
-        format!(
-            "{}abci_query?path=\"/feemarket.feemarket.v1.Query/GasPrices\"&denom={}",
-            rpc_address, gas_price_denom
-        )
+    let dynamic_gas_type = match dynamic_gas_type {
+        Some(dynamic_gas_type) => dynamic_gas_type,
+        None => {
+            // backward compatibility for chains that do not specify dynamic gas type
+            if chain_id.name().starts_with("osmosis") || chain_id.name().starts_with("osmo-test") {
+                &DynamicGasType::Osmosis
+            } else {
+                &DynamicGasType::SkipFeeMarket
+            }
+        }
     };
 
+    debug!("Querying {dynamic_gas_type} base fee from {rpc_address}");
+
+    let url =  dynamic_gas_type.get_url(rpc_address, gas_price_denom);
     let response = reqwest::get(&url).await.map_err(Error::http_request)?;
 
     if !response.status().is_success() {
@@ -58,19 +56,16 @@ pub async fn query_eip_base_fee(
 
     let result: EipBaseFeeHTTPResult = response.json().await.map_err(Error::http_response_body)?;
 
-    let amount = if is_osmosis {
-        extract_dynamic_gas_price_osmosis(result.result.response.value)?
-    } else {
-        extract_dynamic_gas_price(result.result.response.value)?
-    };
+    let amount = dynamic_gas_type
+        .extract_dynamic_gas_price(result.result.response.value)?;
 
     trace!("EIP-1559 base fee: {amount}");
 
     Ok(amount)
 }
 
 /// This method extracts the gas base fee from Skip's feemarket
-fn extract_dynamic_gas_price(encoded: String) -> Result<f64, Error> {
+fn extract_dynamic_gas_price_fee_market(encoded: String) -> Result<f64, Error> {
     let decoded = base64::decode(encoded).map_err(Error::base64_decode)?;
 
     let gas_price_response: GasPriceResponse =
@@ -84,8 +79,8 @@ fn extract_dynamic_gas_price(encoded: String) -> Result<f64, Error> {
     f64::from_str(dec.to_string().as_str()).map_err(Error::parse_float)
 }
 
-/// This method extracts the gas base fee from Osmosis EIP-1559
-fn extract_dynamic_gas_price_osmosis(encoded: String) -> Result<f64, Error> {
+/// This method extracts the gas base fee from Osmosis EIP-1559 and Cosmos EVM EIP-1559
+fn extract_dynamic_gas_price(encoded: String) -> Result<f64, Error> {
     let decoded = base64::decode(encoded).map_err(Error::base64_decode)?;
 
     let dec_proto: DecProto = prost::Message::decode(decoded.as_ref())
@@ -189,3 +184,74 @@ impl fmt::Display for Decimal {
         }
     }
 }
+
+impl DynamicGasType {
+    fn get_url(&self, rpc_address: &Url, gas_price_denom: &str) -> String {
+        match self {
+            DynamicGasType::SkipFeeMarket => format!(
+                "{}abci_query?path=\"/feemarket.feemarket.v1.Query/GasPrices\"&denom={}",
+                rpc_address, gas_price_denom
+            ),
+            DynamicGasType::Osmosis => format!(
+                "{}abci_query?path=\"/osmosis.txfees.v1beta1.Query/GetEipBaseFee\"",
+                rpc_address
+            ),
+            DynamicGasType::CosmosEvm => format!(
+                "{}abci_query?path=\"/cosmos.evm.feemarket.v1.Query/BaseFee\"",
+                rpc_address
+            ),
+        }
+    }
+
+    fn extract_dynamic_gas_price(&self, encoded: String) -> Result<f64, Error> {
+        match self {
+            DynamicGasType::SkipFeeMarket => extract_dynamic_gas_price_fee_market(encoded),
+            DynamicGasType::Osmosis => extract_dynamic_gas_price(encoded),
+            DynamicGasType::CosmosEvm => extract_dynamic_gas_price(encoded),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_dynamic_gas_price_fee_market() {
+        // Test with the provided encoded value
+        let encoded = "ChgKA3VvbRIRMTAwMDAwMDAwMDAwMDAwMDA".to_string();
+
+        let result = extract_dynamic_gas_price_fee_market(encoded);
+
+        assert!(result.is_ok());
+        let gas_price = result.unwrap();
+
+        assert_eq!(gas_price, 0.01);
+    }
+
+    #[test]
+    fn test_extract_dynamic_gas_price_osmosis() {
+        // Test with the provided encoded value
+        let encoded = "ChAyNTAwMDAwMDAwMDAwMDAw".to_string();
+
+        let result = extract_dynamic_gas_price(encoded);
+
+        assert!(result.is_ok());
+        let gas_price = result.unwrap();
+
+        assert_eq!(gas_price, 0.0025);
+    }
+
+    #[test]
+    fn test_extract_dynamic_gas_price_cosmos_evm() {
+        // Test with the provided encoded value
+        let encoded = "ChExMDAwMDAwMDAwMDAwMDAwMA==".to_string();
+
+        let result = extract_dynamic_gas_price(encoded);
+
+        assert!(result.is_ok());
+        let gas_price = result.unwrap();
+
+        assert_eq!(gas_price, 0.01);
+    }
+}

crates/relayer/src/chain/cosmos/gas.rs

@@ -43,7 +43,7 @@ pub async fn dynamic_gas_price(
     rpc_address: &Url,
 ) -> GasPrice {
     if config.dynamic_gas_price.enabled {
-        let dynamic_gas_price = query_eip_base_fee(rpc_address, &config.gas_price.denom, chain_id)
+        let dynamic_gas_price = query_eip_base_fee(rpc_address, &config.gas_price.denom, &config.dynamic_gas_price.r#type, chain_id)
             .await
             .map(|base_fee| base_fee * config.dynamic_gas_price.multiplier)
             .map(|new_price| GasPrice {

crates/relayer/src/config/dynamic_gas.rs

@@ -1,3 +1,4 @@
+use core::fmt;
 use serde::de::Error as DeserializeError;
 use serde::de::Unexpected;
 use serde::Deserialize;
@@ -15,31 +16,51 @@ flex_error::define_error! {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DynamicGasType {
+    SkipFeeMarket,
+    Osmosis,
+    CosmosEvm,
+}
+
+impl fmt::Display for DynamicGasType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DynamicGasType::SkipFeeMarket => write!(f, "SkipFeeMarket"),
+            DynamicGasType::Osmosis => write!(f, "Osmosis"),
+            DynamicGasType::CosmosEvm => write!(f, "CosmosEVM"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Serialize)]
 pub struct DynamicGasPrice {
     pub enabled: bool,
     pub multiplier: f64,
     pub max: f64,
+    pub r#type: Option<DynamicGasType>,
 }
 
 impl DynamicGasPrice {
     const DEFAULT_MULTIPLIER: f64 = 1.1;
     const DEFAULT_MAX: f64 = 0.6;
     const MIN_MULTIPLIER: f64 = 1.0;
 
-    pub fn enabled(multiplier: f64, max: f64) -> Result<Self, Error> {
-        Self::new(true, multiplier, max)
+    pub fn enabled(multiplier: f64, max: f64, r#type: Option<DynamicGasType>) -> Result<Self, Error> {
+        Self::new(true, multiplier, max, r#type)
     }
 
     pub fn disabled() -> Self {
         Self {
             enabled: false,
             multiplier: Self::DEFAULT_MULTIPLIER,
             max: Self::DEFAULT_MAX,
+            r#type: None,
         }
     }
 
-    pub fn new(enabled: bool, multiplier: f64, max: f64) -> Result<Self, Error> {
+    pub fn new(enabled: bool, multiplier: f64, max: f64, r#type: Option<DynamicGasType>) -> Result<Self, Error> {
         if multiplier < Self::MIN_MULTIPLIER {
             return Err(Error::multiplier_too_small(multiplier));
         }
@@ -48,15 +69,17 @@ impl DynamicGasPrice {
             enabled,
             multiplier,
             max,
+            r#type,
         })
     }
 
     // Unsafe GasMultiplier used for test cases only.
-    pub fn unsafe_new(enabled: bool, multiplier: f64, max: f64) -> Self {
+    pub fn unsafe_new(enabled: bool, multiplier: f64, max: f64, r#type: Option<DynamicGasType>) -> Self {
         Self {
             enabled,
             multiplier,
             max,
+            r#type,
         }
     }
 }
@@ -77,15 +100,17 @@ impl<'de> Deserialize<'de> for DynamicGasPrice {
             enabled: bool,
             multiplier: f64,
             max: f64,
+            r#type: Option<DynamicGasType>,
         }
 
         let DynGas {
             enabled,
             multiplier,
             max,
+            r#type,
         } = DynGas::deserialize(deserializer)?;
 
-        DynamicGasPrice::new(enabled, multiplier, max).map_err(|e| match e.detail() {
+        DynamicGasPrice::new(enabled, multiplier, max, r#type).map_err(|e| match e.detail() {
             ErrorDetail::MultiplierTooSmall(_) => D::Error::invalid_value(
                 Unexpected::Float(multiplier),
                 &format!(
@@ -126,7 +151,7 @@ mod tests {
 
     #[test]
     fn safe_gas_multiplier() {
-        let dynamic_gas = DynamicGasPrice::new(true, 0.6, 0.6);
+        let dynamic_gas = DynamicGasPrice::new(true, 0.6, 0.6, None);
         assert!(
             dynamic_gas.is_err(),
             "Gas multiplier should be an error if value is lower than 1.0: {dynamic_gas:?}"
@@ -135,8 +160,55 @@ mod tests {
 
     #[test]
     fn unsafe_gas_multiplier() {
-        let dynamic_gas = DynamicGasPrice::unsafe_new(true, 0.6, 0.4);
+        let dynamic_gas = DynamicGasPrice::unsafe_new(true, 0.6, 0.4, None);
         assert_eq!(dynamic_gas.multiplier, 0.6);
         assert_eq!(dynamic_gas.max, 0.4);
     }
+
+    #[test]
+    fn parse_valid_dynamic_gas_type() {
+        #[derive(Debug, Deserialize)]
+        struct DummyConfig {
+            dynamic_gas: DynamicGasPrice,
+        }
+        let config: DummyConfig = toml::from_str(
+            "dynamic_gas = { enabled = true, multiplier = 1.1, max = 0.6, type = 'skip_fee_market' }",
+        )
+        .unwrap();
+
+        assert_eq!(config.dynamic_gas.multiplier, 1.1);
+        assert_eq!(config.dynamic_gas.max, 0.6);
+        assert_eq!(config.dynamic_gas.r#type, Some(DynamicGasType::SkipFeeMarket));
+    }
+
+    #[test]
+    fn parse_invalid_dynamic_gas_type() {
+        #[derive(Debug, Deserialize)]
+        struct DummyConfig {
+            dynamic_gas: DynamicGasPrice,
+        }
+        let err = toml::from_str::<DummyConfig>(
+            "dynamic_gas = { enabled = true, multiplier = 1.1, max = 0.6, type = 'invalid_type' }",
+        )
+        .unwrap_err()
+        .to_string();
+
+        assert!(err.contains("unknown variant `invalid_type`, expected one of `skip_fee_market`, `osmosis`, `cosmos_evm`"));
+    }
+
+    #[test]
+    fn parse_no_dynamic_gas_type() {
+        #[derive(Debug, Deserialize)]
+        struct DummyConfig {
+            dynamic_gas: DynamicGasPrice,
+        }
+        let config: DummyConfig = toml::from_str(
+            "dynamic_gas = { enabled = true, multiplier = 1.1, max = 0.6 }",
+        )
+        .unwrap();
+
+        assert_eq!(config.dynamic_gas.multiplier, 1.1);
+        assert_eq!(config.dynamic_gas.max, 0.6);
+        assert!(config.dynamic_gas.r#type.is_none());
+    }
 }