feat(api): add EIP-7966 eth_sendRawTransactionSync method

core/bin/external_node/src/config/mod.rs

@@ -216,6 +216,10 @@ impl From<&LocalConfig> for InternalApiConfigBase {
             filters_disabled: web3_rpc.filters_disabled,
             l1_to_l2_txs_paused: false,
             eth_call_gas_cap: web3_rpc.eth_call_gas_cap,
+            send_raw_tx_sync_max_timeout_ms: web3_rpc.send_raw_tx_sync_max_timeout_ms,
+            send_raw_tx_sync_default_timeout_ms: web3_rpc.send_raw_tx_sync_default_timeout_ms,
+            // Default to 1 second polling interval (matches StateKeeperConfig default)
+            send_raw_tx_sync_poll_interval_ms: 1000,
         }
     }
 }

core/bin/external_node/src/config/tests/config.yaml

@@ -85,6 +85,8 @@ api:
     fee_history_limit: 100
     whitelisted_tokens_for_aa:
       - '0x0000000000000000000000000000000000000001'
+    send_raw_tx_sync_max_timeout_ms: 10000
+    send_raw_tx_sync_default_timeout_ms: 2000
 
 contracts:
   l1:

core/bin/external_node/src/config/tests/mod.rs

@@ -305,6 +305,9 @@ fn parsing_from_full_env() {
         EN_API_TREE_API_REMOTE_URL=http://tree/
         # Tree component config
         EN_TREE_API_PORT=2955
+
+        EN_API_WEB3_JSON_RPC_SEND_RAW_TX_SYNC_MAX_TIMEOUT_MS=10000
+        EN_API_WEB3_JSON_RPC_SEND_RAW_TX_SYNC_DEFAULT_TIMEOUT_MS=2000
     "#;
     let env = smart_config::Environment::from_dotenv("test.env", env)
         .unwrap()

core/bin/zksync_server/src/node_builder.rs

@@ -462,8 +462,9 @@ impl MainNodeBuilder {
             pruning_info_refresh_interval: Duration::from_secs(10),
             polling_interval: rpc_config.pubsub_polling_interval,
         };
-        let base = InternalApiConfigBase::new(&self.genesis_config, &rpc_config)
-            .with_l1_to_l2_txs_paused(self.configs.mempool_config.l1_to_l2_txs_paused);
+        let base =
+            InternalApiConfigBase::new(&self.genesis_config, &rpc_config, &state_keeper_config)
+                .with_l1_to_l2_txs_paused(self.configs.mempool_config.l1_to_l2_txs_paused);
         Ok((base, optional_config))
     }
 

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

@@ -402,6 +402,12 @@ pub struct Web3JsonRpcConfig {
     /// (hundreds or thousands RPS).
     #[config(default, alias = "extended_rpc_tracing")]
     pub extended_api_tracing: bool,
+    /// Maximum timeout for `eth_sendRawTransactionSync` in milliseconds.
+    #[config(default_t = 10_000)]
+    pub send_raw_tx_sync_max_timeout_ms: u64,
+    /// Default timeout for `eth_sendRawTransactionSync` in milliseconds.
+    #[config(default_t = 2_000)]
+    pub send_raw_tx_sync_default_timeout_ms: u64,
 }
 
 impl Web3JsonRpcConfig {
@@ -546,6 +552,8 @@ mod tests {
                 extended_api_tracing: true,
                 gas_price_scale_factor_open_batch: Some(1.3),
                 eth_call_gas_cap: None,
+                send_raw_tx_sync_max_timeout_ms: 10000,
+                send_raw_tx_sync_default_timeout_ms: 2000,
             },
             healthcheck: HealthCheckConfig {
                 port: 8081.into(),
@@ -592,6 +600,8 @@ mod tests {
             API_WEB3_JSON_RPC_WEBSOCKET_REQUESTS_PER_MINUTE_LIMIT=10
             API_WEB3_JSON_RPC_MEMPOOL_CACHE_SIZE=10000
             API_WEB3_JSON_RPC_MEMPOOL_CACHE_UPDATE_INTERVAL=50
+            API_WEB3_JSON_RPC_SEND_RAW_TX_SYNC_MAX_TIMEOUT_MS=10000
+            API_WEB3_JSON_RPC_SEND_RAW_TX_SYNC_DEFAULT_TIMEOUT_MS=2000
             API_CONTRACT_VERIFICATION_PORT="3070"
             API_CONTRACT_VERIFICATION_URL="http://127.0.0.1:3070"
             API_WEB3_JSON_RPC_TREE_API_URL="http://tree/"
@@ -658,6 +668,8 @@ mod tests {
             eth_call_gas_cap: null
             request_timeout_sec: 20
             tree_api_url: "http://tree/"
+            send_raw_tx_sync_max_timeout_ms: 10000
+            send_raw_tx_sync_default_timeout_ms: 2000
           prometheus:
             listener_port: 3312
             pushgateway_url: http://127.0.0.1:9091
@@ -721,6 +733,8 @@ mod tests {
             eth_call_gas_cap: null
             request_timeout: 20s
             tree_api_url: "http://tree/"
+            send_raw_tx_sync_max_timeout_ms: 10000
+            send_raw_tx_sync_default_timeout_ms: 2000
           prometheus:
             listener_port: 3312
             pushgateway_url: http://127.0.0.1:9091

core/lib/web3_decl/src/error.rs

@@ -50,6 +50,12 @@ pub enum Web3Error {
     InternalError(#[from] anyhow::Error),
     #[error("Server is shutting down")]
     ServerShuttingDown,
+    #[error("Transaction {0:?} timeout waiting for receipt")]
+    TransactionTimeout(zksync_types::H256),
+    #[error("Transaction processing error: {0}")]
+    TransactionUnready(String),
+    #[error("Invalid timeout. Max timeout is {0}ms")]
+    InvalidTimeout(u64),
 }
 
 /// Client RPC error with additional details: the method name and arguments of the called method.

core/lib/web3_decl/src/namespaces/eth.rs

@@ -153,6 +153,13 @@ pub trait EthNamespace {
     #[method(name = "sendRawTransaction")]
     async fn send_raw_transaction(&self, tx_bytes: Bytes) -> RpcResult<H256>;
 
+    #[method(name = "sendRawTransactionSync")]
+    async fn send_raw_transaction_sync(
+        &self,
+        tx_bytes: Bytes,
+        max_wait_ms: Option<U256>,
+    ) -> RpcResult<TransactionReceipt>;
+
     #[method(name = "syncing")]
     async fn syncing(&self) -> RpcResult<SyncState>;
 

core/node/api_server/src/web3/backend_jsonrpsee/mod.rs

@@ -40,10 +40,13 @@ impl MethodTracer {
             | Web3Error::TooManyTopics
             | Web3Error::FilterNotFound
             | Web3Error::InvalidFilterBlockHash
+            | Web3Error::InvalidTimeout(_)
             | Web3Error::LogsLimitExceeded(_, _, _) => ErrorCode::InvalidParams.code(),
             Web3Error::SubmitTransactionError(_, _)
             | Web3Error::SerializationError(_)
             | Web3Error::ProxyError(_) => 3,
+            Web3Error::TransactionTimeout(_) => 4,
+            Web3Error::TransactionUnready(_) => 5,
             Web3Error::TreeApiUnavailable => 6,
             Web3Error::ServerShuttingDown => ErrorCode::ServerIsBusy.code(),
         };

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

@@ -225,6 +225,16 @@ impl EthNamespaceServer for EthNamespace {
             .map_err(|err| self.current_method().map_err(err))
     }
 
+    async fn send_raw_transaction_sync(
+        &self,
+        tx_bytes: Bytes,
+        max_wait_ms: Option<U256>,
+    ) -> RpcResult<TransactionReceipt> {
+        self.send_raw_transaction_sync_impl(tx_bytes, max_wait_ms)
+            .await
+            .map_err(|err| self.current_method().map_err(err))
+    }
+
     async fn syncing(&self) -> RpcResult<SyncState> {
         Ok(self.syncing_impl())
     }

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

@@ -173,6 +173,9 @@ enum Web3ErrorKind {
     LogsLimitExceeded,
     InvalidFilterBlockHash,
     TreeApiUnavailable,
+    TransactionTimeout,
+    TransactionUnready,
+    InvalidTimeout,
     Internal,
 }
 
@@ -189,6 +192,9 @@ impl Web3ErrorKind {
             Web3Error::LogsLimitExceeded(..) => Self::LogsLimitExceeded,
             Web3Error::InvalidFilterBlockHash => Self::InvalidFilterBlockHash,
             Web3Error::TreeApiUnavailable => Self::TreeApiUnavailable,
+            Web3Error::TransactionTimeout(_) => Self::TransactionTimeout,
+            Web3Error::TransactionUnready(_) => Self::TransactionUnready,
+            Web3Error::InvalidTimeout(_) => Self::InvalidTimeout,
             Web3Error::InternalError(_)
             | Web3Error::MethodNotImplemented
             | Web3Error::ServerShuttingDown => Self::Internal,

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

@@ -695,6 +695,52 @@ impl EthNamespace {
             .map_err(|err| self.current_method().map_submit_err(err))
     }
 
+    pub async fn send_raw_transaction_sync_impl(
+        &self,
+        tx_bytes: Bytes,
+        max_wait_ms: Option<U256>,
+    ) -> Result<TransactionReceipt, Web3Error> {
+        let timeout_ms = if let Some(timeout) = max_wait_ms {
+            let timeout_u64 = timeout.as_u64();
+            if timeout_u64 > self.state.api_config.send_raw_tx_sync_max_timeout_ms {
+                return Err(Web3Error::InvalidTimeout(
+                    self.state.api_config.send_raw_tx_sync_max_timeout_ms,
+                ));
+            }
+            timeout_u64
+        } else {
+            self.state.api_config.send_raw_tx_sync_default_timeout_ms
+        };
+
+        // Submit transaction and get hash
+        let hash = self.send_raw_transaction_impl(tx_bytes).await?;
+
+        // Poll for receipt at regular intervals
+        let poll_interval = std::time::Duration::from_millis(
+            self.state.api_config.send_raw_tx_sync_poll_interval_ms,
+        );
+        let mut interval = tokio::time::interval(poll_interval);
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+
+        let deadline = tokio::time::sleep(std::time::Duration::from_millis(timeout_ms));
+        tokio::pin!(deadline);
+
+        // Check immediately, then poll at intervals
+        loop {
+            tokio::select! {
+                _ = &mut deadline => {
+                    return Err(Web3Error::TransactionTimeout(hash));
+                }
+                _ = interval.tick() => {
+                    if let Some(receipt) = self.get_transaction_receipt_impl(hash).await? {
+                        return Ok(receipt);
+                    }
+                    // Continue waiting
+                }
+            }
+        }
+    }
+
     pub fn accounts_impl(&self) -> Vec<Address> {
         Vec::new()
     }

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

@@ -15,6 +15,7 @@ use vise::GaugeGuard;
 use zksync_config::{
     configs::{
         api::Web3JsonRpcConfig,
+        chain::StateKeeperConfig,
         contracts::{
             chain::L2Contracts,
             ecosystem::{EcosystemCommonContracts, L1SpecificContracts},
@@ -122,10 +123,17 @@ pub struct InternalApiConfigBase {
     pub filters_disabled: bool,
     pub l1_to_l2_txs_paused: bool,
     pub eth_call_gas_cap: Option<u64>,
+    pub send_raw_tx_sync_default_timeout_ms: u64,
+    pub send_raw_tx_sync_max_timeout_ms: u64,
+    pub send_raw_tx_sync_poll_interval_ms: u64,
 }
 
 impl InternalApiConfigBase {
-    pub fn new(genesis: &GenesisConfig, web3_config: &Web3JsonRpcConfig) -> Self {
+    pub fn new(
+        genesis: &GenesisConfig,
+        web3_config: &Web3JsonRpcConfig,
+        state_keeper_config: &StateKeeperConfig,
+    ) -> Self {
         Self {
             l1_chain_id: genesis.l1_chain_id,
             l2_chain_id: genesis.l2_chain_id,
@@ -139,6 +147,11 @@ impl InternalApiConfigBase {
             filters_disabled: web3_config.filters_disabled,
             l1_to_l2_txs_paused: false,
             eth_call_gas_cap: web3_config.eth_call_gas_cap,
+            send_raw_tx_sync_default_timeout_ms: web3_config.send_raw_tx_sync_default_timeout_ms,
+            send_raw_tx_sync_max_timeout_ms: web3_config.send_raw_tx_sync_max_timeout_ms,
+            send_raw_tx_sync_poll_interval_ms: state_keeper_config
+                .l2_block_commit_deadline
+                .as_millis() as u64,
         }
     }
 
@@ -180,6 +193,9 @@ pub struct InternalApiConfig {
     pub l1_to_l2_txs_paused: bool,
     pub settlement_layer: Option<SettlementLayer>,
     pub eth_call_gas_cap: Option<u64>,
+    pub send_raw_tx_sync_default_timeout_ms: u64,
+    pub send_raw_tx_sync_max_timeout_ms: u64,
+    pub send_raw_tx_sync_poll_interval_ms: u64,
 }
 
 impl InternalApiConfig {
@@ -228,19 +244,23 @@ impl InternalApiConfig {
             l1_to_l2_txs_paused: base.l1_to_l2_txs_paused,
             settlement_layer,
             eth_call_gas_cap: base.eth_call_gas_cap,
+            send_raw_tx_sync_default_timeout_ms: base.send_raw_tx_sync_default_timeout_ms,
+            send_raw_tx_sync_max_timeout_ms: base.send_raw_tx_sync_max_timeout_ms,
+            send_raw_tx_sync_poll_interval_ms: base.send_raw_tx_sync_poll_interval_ms,
         }
     }
 
     pub fn new(
         web3_config: &Web3JsonRpcConfig,
+        state_keeper_config: &StateKeeperConfig,
         l1_contracts_config: &SettlementLayerSpecificContracts,
         l1_ecosystem_contracts: &L1SpecificContracts,
         l2_contracts: &L2Contracts,
         genesis_config: &GenesisConfig,
         l1_to_l2_txs_paused: bool,
         settlement_layer: SettlementLayer,
     ) -> Self {
-        let base = InternalApiConfigBase::new(genesis_config, web3_config)
+        let base = InternalApiConfigBase::new(genesis_config, web3_config, state_keeper_config)
             .with_l1_to_l2_txs_paused(l1_to_l2_txs_paused);
         Self::from_base_and_contracts(
             base,

core/node/api_server/src/web3/tests/mod.rs

@@ -278,8 +278,10 @@ async fn test_http_server(test: impl HttpTest) {
     let contracts_config = ContractsConfig::for_tests();
     let web3_config = test.web3_config();
     let genesis = GenesisConfig::for_tests();
+    let state_keeper_config = StateKeeperConfig::for_tests();
     let api_config = InternalApiConfig::new(
         &web3_config,
+        &state_keeper_config,
         &contracts_config.settlement_layer_specific_contracts(),
         &contracts_config.l1_specific_contracts(),
         &contracts_config.l2_contracts(),