account for gas estimation difference during spikes

Author: itegulov

core/lib/types/src/fee_model.rs

@@ -408,6 +408,8 @@ fn compute_batch_fee_model_input_v2(
     // might, so we use U256 for them.
     let l1_batch_overhead_wei = U256::from(l1_gas_price) * U256::from(batch_overhead_l1_gas);
 
+    tracing::info!(%l1_gas_price, %l1_pubdata_price, %l1_batch_overhead_wei, "starting batch fee model computation");
+
     let fair_l2_gas_price = {
         // Firstly, we calculate which part of the overall overhead each unit of L2 gas should cover.
         let l1_batch_overhead_per_gas =
@@ -438,6 +440,8 @@ fn compute_batch_fee_model_input_v2(
         l1_pubdata_price + pubdata_overhead_wei
     };
 
+    tracing::info!(%fair_l2_gas_price, %fair_pubdata_price, "finishing batch fee model computation");
+
     PubdataIndependentBatchFeeModelInput {
         l1_gas_price,
         fair_l2_gas_price,

core/node/api_server/src/web3/namespaces/eth.rs

@@ -100,20 +100,24 @@ impl EthNamespace {
         _block: Option<BlockNumber>,
         state_override: Option<StateOverride>,
     ) -> Result<U256, Web3Error> {
+        tracing::info!("Estimating gas for request: {:?}", request);
         let mut request_with_gas_per_pubdata_overridden = request;
         self.state
             .set_nonce_for_call_request(&mut request_with_gas_per_pubdata_overridden)
             .await?;
 
         if let Some(eip712_meta) = &mut request_with_gas_per_pubdata_overridden.eip712_meta {
+            tracing::info!("Request has eip712 metadata");
             if eip712_meta.gas_per_pubdata == U256::zero() {
+                tracing::info!("But its gas per pubdata is zero");
                 eip712_meta.gas_per_pubdata = DEFAULT_L2_TX_GAS_PER_PUBDATA_BYTE.into();
             }
         }
 
         let is_eip712 = request_with_gas_per_pubdata_overridden
             .eip712_meta
             .is_some();
+        tracing::info!("Is EIP712? {is_eip712}");
         let mut connection = self.state.acquire_connection().await?;
         let block_args = BlockArgs::pending(&mut connection).await?;
         drop(connection);
@@ -122,6 +126,7 @@ impl EthNamespace {
             self.state.api_config.max_tx_size,
             block_args.use_evm_emulator(),
         )?;
+        tracing::info!("Converted to L2 transaction {tx:?}");
 
         // The user may not include the proper transaction type during the estimation of
         // the gas fee. However, it is needed for the bootloader checks to pass properly.
@@ -132,6 +137,7 @@ impl EthNamespace {
         // When we're estimating fee, we are trying to deduce values related to fee, so we should
         // not consider provided ones.
         let gas_price = self.state.tx_sender.gas_price().await?;
+        tracing::info!("Using gas price {gas_price}");
         tx.common_data.fee.max_fee_per_gas = gas_price.into();
         tx.common_data.fee.max_priority_fee_per_gas = tx.common_data.fee.max_fee_per_gas;
 
@@ -153,6 +159,7 @@ impl EthNamespace {
                 search_kind,
             )
             .await?;
+        tracing::info!("Final fee {fee:?}");
         Ok(fee.gas_limit)
     }
 

core/node/api_server/src/web3/state.rs

@@ -425,6 +425,7 @@ impl RpcState {
         call_request: &mut CallRequest,
     ) -> Result<(), Web3Error> {
         if call_request.nonce.is_some() {
+            tracing::info!("Nonce is already set, skipping");
             return Ok(());
         }
         let mut connection = self.acquire_connection().await?;
@@ -437,6 +438,7 @@ impl RpcState {
             .get_address_historical_nonce(from, latest_block_number)
             .await
             .map_err(DalError::generalize)?;
+        tracing::info!("Setting nonce to {}", address_historical_nonce);
         call_request.nonce = Some(address_historical_nonce);
         Ok(())
     }

core/node/fee_model/src/lib.rs

@@ -123,14 +123,15 @@ impl BatchFeeModelInputProvider for ApiFeeInputProvider {
             .context("no batches were found in the DB")?;
 
         if !latest_batch_header.is_sealed {
-            tracing::trace!(
+            tracing::info!(
                 latest_batch_number = %latest_batch_header.number,
+                fee_input = ?latest_batch_header.fee_input,
                 "Found an open batch; reporting its fee input"
             );
             return Ok(latest_batch_header.fee_input);
         }
 
-        tracing::trace!(
+        tracing::info!(
             latest_batch_number = %latest_batch_header.number,
             "No open batch found; fetching from base provider"
         );

core/tests/ts-integration/src/helpers.ts

@@ -3,7 +3,7 @@ import * as zksync from 'zksync-ethers';
 import * as ethers from 'ethers';
 import * as hre from 'hardhat';
 import { ZkSyncArtifact } from '@matterlabs/hardhat-zksync-solc/dist/src/types';
-import { TimeoutError } from 'ethers/src.ts/utils/errors';
+import { TransactionReceipt } from 'ethers';
 
 export const SYSTEM_CONTEXT_ADDRESS = '0x000000000000000000000000000000000000800b';
 
@@ -75,7 +75,7 @@ export async function waitForNewL1Batch(wallet: zksync.Wallet): Promise<zksync.t
     const MAX_ATTEMPTS = 3;
 
     let txResponse = null;
-    let txReceipt = null;
+    let txReceipt: TransactionReceipt | null = null;
     let nonce = Number(await wallet.getNonce());
     for (let i = 0; i < MAX_ATTEMPTS; i++) {
         // Send a dummy transaction and wait for it to execute. We override `maxFeePerGas` as the default ethers behavior
@@ -91,12 +91,22 @@ export async function waitForNewL1Batch(wallet: zksync.Wallet): Promise<zksync.t
         } else {
             console.log('Gas price has not gone up, waiting longer');
         }
-        txReceipt = await wallet.provider.waitForTransaction(txResponse.hash, 1, 3000).catch((_: TimeoutError) => null);
+        txReceipt = await wallet.provider.waitForTransaction(txResponse.hash, 1, 3000).catch((e) => {
+            if (ethers.isError(e, 'TIMEOUT')) {
+                console.log(`Transaction timed out, potentially gas price went up (attempt ${i + 1}/${MAX_ATTEMPTS})`);
+                return null;
+            } else if (ethers.isError(e, 'UNKNOWN_ERROR') && e.message.match(/Not enough gas/)) {
+                console.log(
+                    `Transaction did not have enough gas, likely gas price went up (attempt ${i + 1}/${MAX_ATTEMPTS})`
+                );
+                return null;
+            } else {
+                return Promise.reject(e);
+            }
+        });
         if (txReceipt) {
             // Transaction got executed, so we can safely assume it will be sealed in the next batch
             break;
-        } else {
-            console.log(`Transaction timed out (attempt ${i + 1}/${MAX_ATTEMPTS})`);
         }
     }
     if (!txReceipt) {