feat: base token integration tests

.github/workflows/ci-zk-toolbox-reusable.yml

@@ -87,8 +87,8 @@ jobs:
           --wallet-creation localhost \
           --l1-batch-commit-data-generator-mode rollup \
           --base-token-address ${{ env.address }} \
-          --base-token-price-nominator 3 \
-          --base-token-price-denominator 2 \
+          --base-token-price-nominator 314 \
+          --base-token-price-denominator 1000 \
           --set-as-default false \
           --ignore-prerequisites
 

core/lib/config/src/configs/external_price_api_client.rs

@@ -4,16 +4,22 @@ use serde::Deserialize;
 
 pub const DEFAULT_TIMEOUT_MS: u64 = 10_000;
 
+pub const DEFAULT_FORCED_NEXT_VALUE_FLUCTUATION: u32 = 3;
+
 #[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct ForcedPriceClientConfig {
     /// Forced conversion ratio
     pub numerator: Option<u64>,
     pub denominator: Option<u64>,
-    /// Forced fluctuation. It defines how much percent numerator /
-    /// denominator should fluctuate from their forced values. If it's None or 0, then ForcedPriceClient
+    /// Forced fluctuation. It defines how much percent the ratio
+    /// should fluctuate from their forced values. If it's None or 0, then ForcedPriceClient
     /// will return the same quote every time it's called. Otherwise, ForcedPriceClient will return
     /// forced_quote +/- forced_fluctuation % from its values.
     pub fluctuation: Option<u32>,
+    /// In order to smooth out fluctuation consecutive values returned by forced client will not
+    /// differ more than next_value_fluctuation percent. If it's None, a default of 3% will be applied.
+    #[serde(default = "ExternalPriceApiClientConfig::default_forced_next_value_fluctuation")]
+    pub next_value_fluctuation: u32,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize)]
@@ -31,6 +37,10 @@ impl ExternalPriceApiClientConfig {
         DEFAULT_TIMEOUT_MS
     }
 
+    fn default_forced_next_value_fluctuation() -> u32 {
+        DEFAULT_FORCED_NEXT_VALUE_FLUCTUATION
+    }
+
     pub fn client_timeout(&self) -> Duration {
         Duration::from_millis(self.client_timeout_ms)
     }

core/lib/config/src/testonly.rs

@@ -1081,6 +1081,7 @@ impl Distribution<configs::external_price_api_client::ExternalPriceApiClientConf
                 numerator: self.sample(rng),
                 denominator: self.sample(rng),
                 fluctuation: self.sample(rng),
+                next_value_fluctuation: self.sample(rng),
             }),
         }
     }

core/lib/env_config/src/external_price_api_client.rs

@@ -43,6 +43,7 @@ mod tests {
                 numerator: Some(100),
                 denominator: Some(1),
                 fluctuation: Some(10),
+                next_value_fluctuation: 1,
             }),
         }
     }
@@ -57,6 +58,7 @@ mod tests {
             EXTERNAL_PRICE_API_CLIENT_FORCED_NUMERATOR=100
             EXTERNAL_PRICE_API_CLIENT_FORCED_DENOMINATOR=1
             EXTERNAL_PRICE_API_CLIENT_FORCED_FLUCTUATION=10
+            EXTERNAL_PRICE_API_CLIENT_FORCED_NEXT_VALUE_FLUCTUATION=1
         "#;
         lock.set_env(config);
 

core/lib/external_price_api/src/forced_price_client.rs

@@ -1,17 +1,23 @@
-use std::num::NonZeroU64;
+use std::{
+    cmp::{max, min},
+    num::NonZeroU64,
+};
 
 use async_trait::async_trait;
 use rand::Rng;
+use tokio::sync::RwLock;
 use zksync_config::configs::ExternalPriceApiClientConfig;
 use zksync_types::{base_token_ratio::BaseTokenAPIRatio, Address};
 
 use crate::PriceAPIClient;
 
-// Struct for a a forced price "client" (conversion ratio is always a configured "forced" ratio).
-#[derive(Debug, Clone)]
+// Struct for a forced price "client" (conversion ratio is always a configured "forced" ratio).
+#[derive(Debug)]
 pub struct ForcedPriceClient {
     ratio: BaseTokenAPIRatio,
+    previous_numerator: RwLock<NonZeroU64>,
     fluctuation: Option<u32>,
+    next_value_fluctuation: u32,
 }
 
 impl ForcedPriceClient {
@@ -29,42 +35,71 @@ impl ForcedPriceClient {
         let fluctuation = forced_price_client_config
             .fluctuation
             .map(|x| x.clamp(0, 100));
+        let next_value_fluctuation = forced_price_client_config
+            .next_value_fluctuation
+            .clamp(0, 100);
 
-        Self {
-            ratio: BaseTokenAPIRatio {
+        let ratio = if numerator < 100 && fluctuation.is_some_and(|f| f > 0) {
+            // If numerator is too small we need to multiply by 100 to make sure fluctuations can be applied
+            BaseTokenAPIRatio {
+                numerator: NonZeroU64::new(numerator * 100).unwrap(),
+                denominator: NonZeroU64::new(denominator * 100).unwrap(),
+                ratio_timestamp: chrono::Utc::now(),
+            }
+        } else {
+            BaseTokenAPIRatio {
                 numerator: NonZeroU64::new(numerator).unwrap(),
                 denominator: NonZeroU64::new(denominator).unwrap(),
                 ratio_timestamp: chrono::Utc::now(),
-            },
+            }
+        };
+
+        Self {
+            ratio,
+            previous_numerator: RwLock::new(NonZeroU64::new(numerator).unwrap()),
             fluctuation,
+            next_value_fluctuation,
         }
     }
 }
 
 #[async_trait]
 impl PriceAPIClient for ForcedPriceClient {
-    // Returns a ratio which is 10% higher or lower than the configured forced ratio.
+    /// Returns a ratio which is 10% higher or lower than the configured forced ratio,
+    /// but not different more than 3% than the last value
     async fn fetch_ratio(&self, _token_address: Address) -> anyhow::Result<BaseTokenAPIRatio> {
-        if let Some(x) = self.fluctuation {
-            if x != 0 {
-                let mut rng = rand::thread_rng();
-
-                let mut adjust_range = |value: NonZeroU64| {
-                    let value_f64 = value.get() as f64;
-                    let min = (value_f64 * (1.0 - x as f64 / 100.0)).round() as u64;
-                    let max = (value_f64 * (1.0 + x as f64 / 100.0)).round() as u64;
-                    rng.gen_range(min..=max)
-                };
-                let new_numerator = adjust_range(self.ratio.numerator);
-                let new_denominator = adjust_range(self.ratio.denominator);
+        if let Some(fluctation) = self.fluctuation {
+            let mut previous_numerator = self.previous_numerator.write().await;
+            let mut rng = rand::thread_rng();
+            let numerator_range = (
+                max(
+                    (self.ratio.numerator.get() as f64 * (1.0 - (fluctation as f64 / 100.0)))
+                        .round() as u64,
+                    (previous_numerator.get() as f64
+                        * (1.0 - (self.next_value_fluctuation as f64 / 100.0)))
+                        .round() as u64,
+                ),
+                min(
+                    (self.ratio.numerator.get() as f64 * (1.0 + (fluctation as f64 / 100.0)))
+                        .round() as u64,
+                    (previous_numerator.get() as f64
+                        * (1.0 + (self.next_value_fluctuation as f64 / 100.0)))
+                        .round() as u64,
+                ),
+            );
 
-                return Ok(BaseTokenAPIRatio {
-                    numerator: NonZeroU64::new(new_numerator).unwrap_or(self.ratio.numerator),
-                    denominator: NonZeroU64::new(new_denominator).unwrap_or(self.ratio.denominator),
-                    ratio_timestamp: chrono::Utc::now(),
-                });
-            }
+            let new_numerator =
+                NonZeroU64::new(rng.gen_range(numerator_range.0..=numerator_range.1))
+                    .unwrap_or(self.ratio.numerator);
+            let adjusted_ratio = BaseTokenAPIRatio {
+                numerator: new_numerator,
+                denominator: self.ratio.denominator,
+                ratio_timestamp: chrono::Utc::now(),
+            };
+            *previous_numerator = new_numerator;
+            Ok(adjusted_ratio)
+        } else {
+            Ok(self.ratio)
         }
-        Ok(self.ratio)
     }
 }

core/lib/protobuf_config/src/external_price_api_client.rs

@@ -17,6 +17,9 @@ impl ProtoRepr for proto::ExternalPriceApiClient {
                     numerator: self.forced_numerator,
                     denominator: self.forced_denominator,
                     fluctuation: self.forced_fluctuation,
+                    next_value_fluctuation: self.forced_next_value_fluctuation.unwrap_or(
+                        configs::external_price_api_client::DEFAULT_FORCED_NEXT_VALUE_FLUCTUATION,
+                    ),
                 }),
             },
         )
@@ -26,6 +29,7 @@ impl ProtoRepr for proto::ExternalPriceApiClient {
         let numerator = this.forced.as_ref().and_then(|x| x.numerator);
         let denominator = this.forced.as_ref().and_then(|x| x.denominator);
         let fluctuation = this.forced.as_ref().and_then(|x| x.fluctuation);
+        let next_value_fluctuation = this.forced.as_ref().map(|x| x.next_value_fluctuation);
 
         Self {
             source: Some(this.source.clone()),
@@ -35,6 +39,7 @@ impl ProtoRepr for proto::ExternalPriceApiClient {
             forced_numerator: numerator,
             forced_denominator: denominator,
             forced_fluctuation: fluctuation,
+            forced_next_value_fluctuation: next_value_fluctuation,
         }
     }
 }

core/lib/protobuf_config/src/proto/config/external_price_api_client.proto

@@ -10,4 +10,5 @@ message ExternalPriceApiClient {
   optional uint64 forced_numerator = 5;
   optional uint64 forced_denominator = 6;
   optional uint32 forced_fluctuation = 7;
+  optional uint32 forced_next_value_fluctuation = 8;
 }

core/node/base_token_adjuster/src/base_token_l1_behaviour.rs

@@ -220,10 +220,16 @@ impl BaseTokenL1Behaviour {
                 if receipt.status == Some(1.into()) {
                     return Ok(receipt.gas_used);
                 }
+                let reason = (*l1_params.eth_client)
+                    .as_ref()
+                    .failure_reason(hash)
+                    .await
+                    .context("failed getting failure reason of `setTokenMultiplier` transaction")?;
                 return Err(anyhow::Error::msg(format!(
-                    "`setTokenMultiplier` transaction {:?} failed with status {:?}",
+                    "`setTokenMultiplier` transaction {:?} failed with status {:?}, reason: {:?}",
                     hex::encode(hash),
-                    receipt.status
+                    receipt.status,
+                    reason
                 )));
             } else {
                 tokio::time::sleep(sleep_duration).await;

core/node/external_proof_integration_api/src/lib.rs

@@ -4,8 +4,6 @@ mod middleware;
 mod processor;
 mod types;
 
-pub use crate::processor::Processor;
-
 use std::net::SocketAddr;
 
 use anyhow::Context;
@@ -20,6 +18,7 @@ use tokio::sync::watch;
 use types::{ExternalProof, ProofGenerationDataResponse};
 use zksync_basic_types::L1BatchNumber;
 
+pub use crate::processor::Processor;
 use crate::{
     metrics::{CallOutcome, Method},
     middleware::MetricsMiddleware,

core/tests/ts-integration/src/retry-provider.ts

@@ -57,9 +57,10 @@ export class RetryProvider extends zksync.Provider {
 
     override _wrapTransactionReceipt(receipt: any): zksync.types.TransactionReceipt {
         const wrapped = super._wrapTransactionReceipt(receipt);
-        this.reporter.debug(
-            `Obtained receipt for transaction ${receipt.transactionHash}: blockNumber=${receipt.blockNumber}, status=${receipt.status}`
-        );
+        if (process.env.ZKSYNC_DEBUG_TX_RECEIPT)
+            this.reporter.debug(
+                `Obtained receipt for transaction ${receipt.transactionHash}: blockNumber=${receipt.blockNumber}, status=${receipt.status}`
+            );
         return wrapped;
     }
 }

core/tests/ts-integration/tests/base-token.test.ts

@@ -36,9 +36,8 @@ describe('base ERC20 contract checks', () => {
         const numerator = Number(await zksyncContract.baseTokenGasPriceMultiplierNominator());
         const denominator = Number(await zksyncContract.baseTokenGasPriceMultiplierDenominator());
 
-        // checking that the numerator and denominator don't have their default values
-        expect(numerator).toBe(3);
-        expect(denominator).toBe(2);
+        expect(numerator).toBe(314);
+        expect(denominator).toBe(1000);
     });
 
     test('Can perform a deposit', async () => {