feat(main): base token gas oracle switch conversion rate to BigDecimal

core/node/base_token_fetcher/Cargo.toml

@@ -18,6 +18,7 @@ metrics.workspace = true
 tokio = { workspace = true, features = ["time"] }
 anyhow.workspace = true
 async-trait.workspace = true
+bigdecimal.workspace = true
 
 reqwest = { workspace = true, features = ["blocking", "json"] }
 hex.workspace = true

core/node/base_token_fetcher/src/lib.rs

@@ -1,10 +1,15 @@
-use std::{cmp::min, sync::Arc, time::Duration};
+use std::{
+    cmp::min,
+    str::FromStr,
+    sync::{Arc, Mutex},
+    time::Duration,
+};
 
 use anyhow::Context;
 use async_trait::async_trait;
+use bigdecimal::BigDecimal;
 use hex::ToHex;
-use metrics::atomics::AtomicU64;
-use tokio::{sync::Mutex, time::sleep};
+use tokio::time::sleep;
 use zksync_config::configs::BaseTokenFetcherConfig;
 
 const MAX_CONVERSION_RATE_FETCH_RETRIES: u8 = 10;
@@ -13,7 +18,7 @@ const MAX_CONVERSION_RATE_FETCH_RETRIES: u8 = 10;
 /// determine gas prices, as they partially depend on L1 gas prices, denominated in `eth`.
 #[async_trait]
 pub trait ConversionRateFetcher: 'static + std::fmt::Debug + Send + Sync {
-    fn conversion_rate(&self) -> anyhow::Result<u64>;
+    fn conversion_rate(&self) -> anyhow::Result<BigDecimal>;
     async fn update(&self) -> anyhow::Result<()>;
 }
 
@@ -32,8 +37,8 @@ impl NoOpConversionRateFetcher {
 
 #[async_trait]
 impl ConversionRateFetcher for NoOpConversionRateFetcher {
-    fn conversion_rate(&self) -> anyhow::Result<u64> {
-        Ok(1)
+    fn conversion_rate(&self) -> anyhow::Result<BigDecimal> {
+        Ok(BigDecimal::from(1))
     }
 
     async fn update(&self) -> anyhow::Result<()> {
@@ -46,7 +51,7 @@ impl ConversionRateFetcher for NoOpConversionRateFetcher {
 #[derive(Debug)]
 pub struct BaseTokenFetcher {
     pub config: BaseTokenFetcherConfig,
-    pub latest_to_eth_conversion_rate: AtomicU64,
+    pub latest_to_eth_conversion_rate: Arc<Mutex<BigDecimal>>,
     http_client: reqwest::Client,
     error_reporter: Arc<Mutex<ErrorReporter>>,
 }
@@ -55,23 +60,25 @@ impl BaseTokenFetcher {
     pub async fn new(config: BaseTokenFetcherConfig) -> anyhow::Result<Self> {
         let http_client = reqwest::Client::new();
 
-        let conversion_rate = http_client
+        let conversion_rate_str = http_client
             .get(format!(
                 "{}/conversion_rate/0x{}",
                 config.host,
                 config.token_address.encode_hex::<String>()
             ))
             .send()
             .await?
-            .json::<u64>()
+            .json::<String>()
             .await
             .context("Unable to parse the response of the native token conversion rate server")?;
+        let conversion_rate = BigDecimal::from_str(&conversion_rate_str)
+            .context("Unable to parse the response of the native token conversion rate server")?;
 
         let error_reporter = Arc::new(Mutex::new(ErrorReporter::new()));
 
         Ok(Self {
             config,
-            latest_to_eth_conversion_rate: AtomicU64::new(conversion_rate),
+            latest_to_eth_conversion_rate: Arc::new(Mutex::new(conversion_rate)),
             http_client,
             error_reporter,
         })
@@ -81,9 +88,9 @@ impl BaseTokenFetcher {
     pub async fn new_with_timeout(config: BaseTokenFetcherConfig) -> anyhow::Result<Self> {
         let http_client = reqwest::Client::new();
 
-        let mut conversion_rate = None;
+        let mut conversion_rate_str = None;
         let mut tries = 0;
-        while conversion_rate.is_none() && tries < MAX_CONVERSION_RATE_FETCH_RETRIES {
+        while conversion_rate_str.is_none() && tries < MAX_CONVERSION_RATE_FETCH_RETRIES {
             match http_client
                 .get(format!(
                     "{}/conversion_rate/0x{}",
@@ -94,7 +101,7 @@ impl BaseTokenFetcher {
                 .await
             {
                 Ok(res) => {
-                    conversion_rate = Some(res.json::<u64>().await.context(
+                    conversion_rate_str = Some(res.json::<String>().await.context(
                         "Unable to parse the response of the native token conversion rate server",
                     )?);
                 }
@@ -105,12 +112,14 @@ impl BaseTokenFetcher {
             }
         }
 
-        let conversion_rate = conversion_rate
+        let conversion_rate = conversion_rate_str
             .ok_or_else(|| anyhow::anyhow!("Failed to fetch the native token conversion rate"))?;
+        let conversion_rate = BigDecimal::from_str(&conversion_rate)
+            .context("Unable to parse the response of the native token conversion rate server")?;
         let error_reporter = Arc::new(Mutex::new(ErrorReporter::new()));
         Ok(Self {
             config,
-            latest_to_eth_conversion_rate: AtomicU64::new(conversion_rate),
+            latest_to_eth_conversion_rate: Arc::new(Mutex::new(conversion_rate)),
             http_client,
             error_reporter,
         })
@@ -119,11 +128,8 @@ impl BaseTokenFetcher {
 
 #[async_trait]
 impl ConversionRateFetcher for BaseTokenFetcher {
-    fn conversion_rate(&self) -> anyhow::Result<u64> {
-        anyhow::Ok(
-            self.latest_to_eth_conversion_rate
-                .load(std::sync::atomic::Ordering::Relaxed),
-        )
+    fn conversion_rate(&self) -> anyhow::Result<BigDecimal> {
+        Ok(self.latest_to_eth_conversion_rate.lock().unwrap().clone())
     }
 
     async fn update(&self) -> anyhow::Result<()> {
@@ -138,17 +144,20 @@ impl ConversionRateFetcher for BaseTokenFetcher {
             .await
         {
             Ok(response) => {
-                let conversion_rate = response.json::<u64>().await.context(
+                let conversion_rate_str = response.json::<String>().await.context(
                     "Unable to parse the response of the native token conversion rate server",
                 )?;
-                self.latest_to_eth_conversion_rate
-                    .store(conversion_rate, std::sync::atomic::Ordering::Relaxed);
-                self.error_reporter.lock().await.reset();
+                *self.latest_to_eth_conversion_rate.lock().unwrap() =
+                    BigDecimal::from_str(&conversion_rate_str).context(
+                        "Unable to parse the response of the native token conversion rate server",
+                    )?;
+
+                self.error_reporter.lock().unwrap().reset();
             }
             Err(err) => self
                 .error_reporter
                 .lock()
-                .await
+                .unwrap()
                 .process(anyhow::anyhow!(err)),
         }
 

core/node/dev_api_conversion_rate/Cargo.toml

@@ -11,6 +11,7 @@ categories.workspace = true
 
 [dependencies]
 zksync_config.workspace = true
+bigdecimal.workspace = true
 
 tokio.workspace = true
 anyhow.workspace = true

core/node/dev_api_conversion_rate/src/lib.rs

@@ -1,4 +1,11 @@
-use axum::{extract, extract::Json, routing::get, Router};
+use std::str::FromStr;
+
+use axum::{
+    extract::{self, Json},
+    routing::get,
+    Router,
+};
+use bigdecimal::BigDecimal;
 use tokio::sync::watch;
 use zksync_config::configs::base_token_fetcher::BaseTokenFetcherConfig;
 
@@ -30,12 +37,12 @@ pub async fn run_server(
 
 /// Basic handler that responds with a static string with the format expected by the token fetcher component
 /// Returns 1 in the case of using ETH as the base token, a hardcoded 42 otherwise
-async fn get_conversion_rate(extract::Path(token_address): extract::Path<String>) -> Json<u64> {
+async fn get_conversion_rate(extract::Path(token_address): extract::Path<String>) -> Json<String> {
     if token_address == "0x0000000000000000000000000000000000000000"
         || token_address == "0x0000000000000000000000000000000000000001"
     {
-        return Json(1);
+        return Json(BigDecimal::from(1).to_string());
     }
     tracing::info!("Received request for conversion rate");
-    Json(42)
+    Json(BigDecimal::from_str("42.5").unwrap().to_string())
 }

core/node/fee_model/src/l1_gas_price/gas_adjuster/mod.rs

@@ -9,6 +9,7 @@ use std::{
 use tokio::sync::watch;
 use zksync_base_token_fetcher::ConversionRateFetcher;
 use zksync_config::{configs::eth_sender::PubdataSendingMode, GasAdjusterConfig};
+use zksync_dal::BigDecimal;
 use zksync_eth_client::{Error, EthInterface};
 use zksync_types::{commitment::L1BatchCommitmentMode, L1_GAS_PER_PUBDATA_BYTE, U256, U64};
 use zksync_web3_decl::client::{DynClient, L1};
@@ -178,9 +179,21 @@ impl GasAdjuster {
         let calculated_price =
             (self.config.internal_l1_pricing_multiplier * effective_gas_price as f64) as u64;
 
-        let conversion_rate = self.base_token_fetcher.conversion_rate().unwrap_or(1);
+        let conversion_rate = self
+            .base_token_fetcher
+            .conversion_rate()
+            .unwrap_or(BigDecimal::from(1));
+        let bound_gas_price = BigDecimal::from(self.bound_gas_price(calculated_price));
 
-        self.bound_gas_price(calculated_price) * conversion_rate
+        U256::from_dec_str(
+            &match (conversion_rate * bound_gas_price).round(0) {
+                zero if zero == BigDecimal::from(0) => BigDecimal::from(1),
+                val => val,
+            }
+            .to_string(),
+        )
+        .unwrap()
+        .as_u64()
     }
 
     pub(crate) fn estimate_effective_pubdata_price(&self) -> u64 {
@@ -207,9 +220,22 @@ impl GasAdjuster {
                     * BLOB_GAS_PER_BYTE as f64
                     * self.config.internal_pubdata_pricing_multiplier;
 
-                let conversion_rate = self.base_token_fetcher.conversion_rate().unwrap_or(1);
-
-                self.bound_blob_base_fee(calculated_price) * conversion_rate
+                let conversion_rate = self
+                    .base_token_fetcher
+                    .conversion_rate()
+                    .unwrap_or(BigDecimal::from(1));
+                let bound_blob_base_fee =
+                    BigDecimal::from(self.bound_blob_base_fee(calculated_price));
+
+                U256::from_dec_str(
+                    &match (conversion_rate * bound_blob_base_fee).round(0) {
+                        zero if zero == BigDecimal::from(0) => BigDecimal::from(1),
+                        val => val,
+                    }
+                    .to_string(),
+                )
+                .unwrap()
+                .as_u64()
             }
             PubdataSendingMode::Calldata => {
                 self.estimate_effective_gas_price() * self.pubdata_byte_gas()