feat: add block.timestamp asserter for AA

core/bin/zksync_server/src/node_builder.rs

@@ -305,7 +305,20 @@ impl MainNodeBuilder {
     fn add_tx_sender_layer(mut self) -> anyhow::Result<Self> {
         let sk_config = try_load_config!(self.configs.state_keeper_config);
         let rpc_config = try_load_config!(self.configs.api_config).web3_json_rpc;
-        let timestamp_asserter_config = try_load_config!(self.configs.timestamp_asserter_config);
+
+        let timestamp_asserter_params = match self.contracts_config.l2_timestamp_asserter_addr {
+            Some(address) => {
+                let timestamp_asserter_config =
+                    try_load_config!(self.configs.timestamp_asserter_config);
+                Some(TimestampAsserterParams {
+                    address,
+                    min_time_till_end: Duration::from_secs(
+                        timestamp_asserter_config.min_time_till_end_sec as u64,
+                    ),
+                })
+            }
+            None => None,
+        };
         let postgres_storage_caches_config = PostgresStorageCachesConfig {
             factory_deps_cache_size: rpc_config.factory_deps_cache_size() as u64,
             initial_writes_cache_size: rpc_config.initial_writes_cache_size() as u64,
@@ -325,14 +338,7 @@ impl MainNodeBuilder {
                     .fee_account
                     .address(),
                 self.genesis_config.l2_chain_id,
-                self.contracts_config
-                    .l2_timestamp_asserter_addr
-                    .map(|address| TimestampAsserterParams {
-                        address,
-                        min_time_till_end: Duration::from_secs(
-                            timestamp_asserter_config.min_time_till_end_sec as u64,
-                        ),
-                    }),
+                timestamp_asserter_params,
             ),
             postgres_storage_caches_config,
             rpc_config.vm_concurrency_limit(),

core/lib/dal/src/transactions_dal.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt, time::Duration};
+use std::{cmp::min, collections::HashMap, fmt, time::Duration};
 
 use bigdecimal::BigDecimal;
 use itertools::Itertools;
@@ -316,15 +316,16 @@ impl TransactionsDal<'_, '_> {
         let nanosecs = ((tx.received_timestamp_ms % 1000) * 1_000_000) as u32;
         #[allow(deprecated)]
         let received_at = NaiveDateTime::from_timestamp_opt(secs, nanosecs).unwrap();
+        let max_timestamp = NaiveDateTime::MAX.and_utc().timestamp() as u64;
         #[allow(deprecated)]
-        let timestamp_asserter_range_start = validation_traces
-            .timestamp_asserter_range
-            .clone()
-            .map(|x| NaiveDateTime::from_timestamp_opt(x.start as i64, 0).unwrap());
+        let timestamp_asserter_range_start =
+            validation_traces.timestamp_asserter_range.clone().map(|x| {
+                NaiveDateTime::from_timestamp_opt(min(x.start, max_timestamp) as i64, 0).unwrap()
+            });
         #[allow(deprecated)]
-        let timestamp_asserter_range_end = validation_traces
-            .timestamp_asserter_range
-            .map(|x| NaiveDateTime::from_timestamp_opt(x.end as i64, 0).unwrap());
+        let timestamp_asserter_range_end = validation_traces.timestamp_asserter_range.map(|x| {
+            NaiveDateTime::from_timestamp_opt(min(x.end, max_timestamp) as i64, 0).unwrap()
+        });
         // Besides just adding or updating(on conflict) the record, we want to extract some info
         // from the query below, to indicate what actually happened:
         // 1) transaction is added

core/node/api_server/src/tx_sender/tests/send_tx.rs

@@ -1,6 +1,9 @@
 //! Tests for sending raw transactions.
 
+use std::ops::Range;
+
 use assert_matches::assert_matches;
+use chrono::NaiveDateTime;
 use test_casing::test_casing;
 use zksync_multivm::interface::{tracer::ValidationTraces, ExecutionResult};
 use zksync_node_fee_model::MockBatchFeeParamsProvider;
@@ -309,8 +312,7 @@ async fn sending_transaction_out_of_gas() {
     assert_matches!(vm_result.result, ExecutionResult::Revert { .. });
 }
 
-#[tokio::test]
-async fn submitting_tx_with_validation_traces() {
+async fn submit_tx_with_validation_traces(actual_range: Range<u64>, expected_range: Range<i64>) {
     // This test verifies that when a transaction produces ValidationTraces,
     // range_start and range_end get persisted in the database
     let pool = ConnectionPool::<Core>::constrained_test_pool(1).await;
@@ -344,7 +346,7 @@ async fn submitting_tx_with_validation_traces() {
     tx_executor.set_tx_validation_traces_responses(move |tx, _| {
         assert_eq!(tx.hash(), tx_hash);
         ValidationTraces {
-            timestamp_asserter_range: Some(10..20),
+            timestamp_asserter_range: Some(actual_range.clone()),
         }
     });
 
@@ -363,19 +365,34 @@ async fn submitting_tx_with_validation_traces() {
         .unwrap()
         .expect("transaction is not persisted");
     assert_eq!(
-        10,
+        expected_range.start,
         storage_tx
             .timestamp_asserter_range_start
             .unwrap()
             .and_utc()
             .timestamp()
     );
     assert_eq!(
-        20,
+        expected_range.end,
         storage_tx
             .timestamp_asserter_range_end
             .unwrap()
             .and_utc()
             .timestamp()
     );
 }
+
+#[tokio::test]
+async fn submitting_tx_with_validation_traces() {
+    // This test verifies that when a transaction produces ValidationTraces,
+    // range_start and range_end get persisted in the database
+    submit_tx_with_validation_traces(10..20, 10..20).await;
+}
+
+#[tokio::test]
+async fn submitting_tx_with_validation_traces_resulting_into_overflow() {
+    // This test verifies that the timestamp in ValidationTraces is capped at
+    // the maximum value supported by the NaiveDateTime type
+    submit_tx_with_validation_traces(10..u64::MAX, 10..NaiveDateTime::MAX.and_utc().timestamp())
+        .await;
+}

core/tests/ts-integration/tests/custom-account.test.ts

@@ -192,19 +192,41 @@ describe('Tests for the custom account behavior', () => {
 
         const tx = await erc20.transfer.populateTransaction(alice.address, TRANSFER_AMOUNT);
 
-        await expect(
-            sendCustomAccountTransaction(
+        try {
+            await sendCustomAccountTransaction(
                 tx as zksync.types.Transaction,
                 alice.provider,
                 customAccountAddress,
                 testMaster.environment().l2ChainId,
                 undefined,
                 undefined,
                 false
-            )
-        ).toBeRejected(
-            'failed to validate the transaction. reason: Validation revert: Account validation error: Timestamp is out of range'
-        );
+            );
+            expect(null).fail('The transaction was expected to fail');
+        } catch (e) {
+            const err = e as Error;
+            expect(err.message).toContain(
+                'failed to validate the transaction. reason: Validation revert: Account validation error'
+            );
+            const functionSelectorMatch = err.message.match(/function_selector\s=\s(0x[0-9a-fA-F]{8})/);
+            const calldataMatch = err.message.match(/data\s=\s(0x[0-9a-fA-F]+)/);
+
+            if (!functionSelectorMatch || !calldataMatch) {
+                expect(null).fail('Function selector or calldata not found in the error message');
+            }
+
+            const functionSelector = functionSelectorMatch![1];
+            const calldata = calldataMatch![1];
+
+            const startHex = calldata.slice(74, 138);
+            const endHex = calldata.slice(138);
+            const start = BigInt(`0x${startHex}`);
+            const end = BigInt(`0x${endHex}`);
+
+            expect(functionSelector).toBe('0x3d5740d9');
+            expect(start).toBe(BigInt(rangeStart));
+            expect(end).toBe(BigInt(rangeEnd));
+        }
     });
 
     test('Should fail the validation with incorrect signature', async () => {