Merge pull request #34 from SeismicSystems/h/851-missing-block-validation-check

fix: enforce tx expiration at block execution time

Author: HenryMBaldwin

crates/evm/src/block/error.rs

@@ -4,7 +4,7 @@ use alloc::{
     string::{String, ToString},
 };
 use alloy_primitives::B256;
-use seismic_alloy_consensus::InputDecryptionElementsError;
+use seismic_alloy_consensus::{InputDecryptionElementsError, SeismicValidationError};
 
 /// Block validation error.
 #[derive(Debug, thiserror::Error)]
@@ -152,6 +152,9 @@ pub enum InternalBlockExecutionError {
     /// Unable to decrypt calldata of seismic tx
     #[error("Failed to decrypt seismic tx: {0}")]
     FailedToDecryptSeismicTx(InputDecryptionElementsError),
+    /// Seismic transaction failed block-level validation (expiration, recent block hash)
+    #[error("Seismic tx validation failed: {0}")]
+    SeismicValidationFailed(SeismicValidationError),
     /// Arbitrary Block Executor Errors
     #[error(transparent)]
     Other(Box<dyn core::error::Error + Send + Sync + 'static>),

crates/seismic-evm/src/block/mod.rs

@@ -26,8 +26,8 @@ use alloy_evm::{
     block::{CommitChanges, ExecutableTx, InternalBlockExecutionError},
     FromTxWithEncoded, RecoveredTx,
 };
-use revm::context::result::ExecutionResult;
-use seismic_alloy_consensus::InputDecryptionElements;
+use revm::context::{result::ExecutionResult, BlockEnv};
+use seismic_alloy_consensus::{InputDecryptionElements, SeismicValidationError};
 
 type SeismicBlockExecutionCtx<'a> = EthBlockExecutionCtx<'a>;
 
@@ -65,6 +65,27 @@ where
     }
 }
 
+/// Rejects Seismic transactions whose `expires_at_block` is before the current block.
+/// Non-Seismic transaction types are passed through without validation.
+fn validate_expiration(
+    tx: &impl InputDecryptionElements,
+    block: &BlockEnv,
+) -> Result<(), BlockExecutionError> {
+    if let Ok(elements) = tx.get_decryption_elements() {
+        let current_block: u64 = block.number.saturating_to();
+        if current_block > elements.expires_at_block {
+            return Err(InternalBlockExecutionError::SeismicValidationFailed(
+                SeismicValidationError::TransactionExpired {
+                    current_block,
+                    expires_at_block: elements.expires_at_block,
+                },
+            )
+            .into());
+        }
+    }
+    Ok(())
+}
+
 impl<'db, DB, E, Spec, R> BlockExecutor for SeismicBlockExecutor<'_, E, Spec, R>
 where
     DB: Database + 'db,
@@ -91,16 +112,14 @@ where
         tx: impl ExecutableTx<Self>,
         f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>) -> CommitChanges,
     ) -> Result<Option<u64>, BlockExecutionError> {
-        // Convert from ExecutableTx<Self> to R::Transaction,
-        // which has the InputDecryptionElements bound
         let receipt_tx: &<R as ReceiptBuilder>::Transaction = RecoveredTx::tx(&tx);
+        validate_expiration(receipt_tx, self.evm().block())?;
 
         let signer = RecoveredTx::signer(&tx);
         let plaintext_base = receipt_tx
             .plaintext_copy(&self.purpose_keys.tx_io_sk, *signer)
             .map_err(|e| InternalBlockExecutionError::FailedToDecryptSeismicTx(e))?;
 
-        // call inner
         let recovered = Recovered::new_unchecked(plaintext_base, *signer);
         self.inner.execute_transaction_with_commit_condition(&recovered, f)
     }
@@ -110,16 +129,14 @@ where
         tx: impl ExecutableTx<Self>,
         f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>),
     ) -> Result<u64, BlockExecutionError> {
-        // Convert from ExecutableTx<Self> to R::Transaction,
-        // which has the InputDecryptionElements bound
         let receipt_tx: &<R as ReceiptBuilder>::Transaction = RecoveredTx::tx(&tx);
+        validate_expiration(receipt_tx, self.evm().block())?;
 
         let signer = RecoveredTx::signer(&tx);
         let plaintext_base = receipt_tx
             .plaintext_copy(&self.purpose_keys.tx_io_sk, *signer)
             .map_err(|e| InternalBlockExecutionError::FailedToDecryptSeismicTx(e))?;
 
-        // call inner
         let recovered = Recovered::new_unchecked(plaintext_base, *signer);
         self.inner.execute_transaction_with_result_closure(&recovered, f)
     }
@@ -339,16 +356,11 @@ mod tests {
         return tx_envelope;
     }
 
-    fn sample_seismic_tx<'a>(setup: &SetupTest<'a>, plaintext: &str) -> TxSeismic {
-        let seismic_elements = TxSeismicElements {
-            encryption_pubkey: setup.encryption_pubkey,
-            encryption_nonce: U96::from_be_slice(&setup.encryption_nonce.0),
-            message_version: 0,
-            recent_block_hash: alloy_primitives::B256::from_slice(&[1u8; 32]),
-            expires_at_block: 1000000,
-            signed_read: false,
-        };
-
+    fn sample_seismic_tx_with_elements<'a>(
+        setup: &SetupTest<'a>,
+        plaintext: &str,
+        seismic_elements: TxSeismicElements,
+    ) -> TxSeismic {
         let pt_bytes = Bytes::from(plaintext.as_bytes().to_vec());
 
         let tx_metadata = TxSeismicMetadata {
@@ -378,6 +390,18 @@ mod tests {
         }
     }
 
+    fn sample_seismic_tx<'a>(setup: &SetupTest<'a>, plaintext: &str) -> TxSeismic {
+        let seismic_elements = TxSeismicElements {
+            encryption_pubkey: setup.encryption_pubkey,
+            encryption_nonce: U96::from_be_slice(&setup.encryption_nonce.0),
+            message_version: 0,
+            recent_block_hash: alloy_primitives::B256::from_slice(&[1u8; 32]),
+            expires_at_block: 1000000,
+            signed_read: false,
+        };
+        sample_seismic_tx_with_elements(setup, plaintext, seismic_elements)
+    }
+
     #[test]
     fn test_transaction_decryption_in_executor() {
         let db = InMemoryDB::default();
@@ -425,4 +449,116 @@ mod tests {
         let result = executor.execute_transaction(recovered);
         assert!(result.is_err(), "expected transaction to fail, but got: {:?}", result);
     }
+
+    #[test]
+    fn test_expired_tx_rejected() {
+        let db = InMemoryDB::default();
+        let mut state = StateBuilder::new_with_database(db).build();
+
+        let setup = setup_test(&mut state);
+
+        // Set block number to 100 so the tx with expires_at_block=50 is expired
+        let mut block_env = BlockEnv::default();
+        block_env.number = U256::from(100);
+
+        let evm = setup.evm_factory.create_evm(
+            &mut state,
+            EvmEnv::new(CfgEnv::new_with_spec(SeismicSpecId::MERCURY), block_env),
+        );
+        let mut executor = setup.executor_factory.create_executor(evm, setup.ctx.clone());
+
+        let plaintext = "hello world";
+        let seismic_elements = TxSeismicElements {
+            encryption_pubkey: setup.encryption_pubkey,
+            encryption_nonce: U96::from_be_slice(&setup.encryption_nonce.0),
+            message_version: 0,
+            recent_block_hash: alloy_primitives::B256::from_slice(&[1u8; 32]),
+            expires_at_block: 50,
+            signed_read: false,
+        };
+        let tx_seismic = sample_seismic_tx_with_elements(&setup, plaintext, seismic_elements);
+        let tx_envelope = get_tx_envelope(&setup, tx_seismic);
+        let recovered = Recovered::new_unchecked(&tx_envelope, setup.signer);
+
+        let result = executor.execute_transaction(recovered);
+        assert!(
+            result.is_err(),
+            "expired transaction should be rejected, but it was accepted"
+        );
+    }
+
+    #[test]
+    fn test_tx_at_exact_expiry_block_accepted() {
+        let db = InMemoryDB::default();
+        let mut state = StateBuilder::new_with_database(db).build();
+
+        let setup = setup_test(&mut state);
+
+        // Set block number exactly equal to expires_at_block (should still be valid)
+        let mut block_env = BlockEnv::default();
+        block_env.number = U256::from(100);
+
+        let evm = setup.evm_factory.create_evm(
+            &mut state,
+            EvmEnv::new(CfgEnv::new_with_spec(SeismicSpecId::MERCURY), block_env),
+        );
+        let mut executor = setup.executor_factory.create_executor(evm, setup.ctx.clone());
+
+        let plaintext = "hello world";
+        let seismic_elements = TxSeismicElements {
+            encryption_pubkey: setup.encryption_pubkey,
+            encryption_nonce: U96::from_be_slice(&setup.encryption_nonce.0),
+            message_version: 0,
+            recent_block_hash: alloy_primitives::B256::from_slice(&[1u8; 32]),
+            expires_at_block: 100,
+            signed_read: false,
+        };
+        let tx_seismic = sample_seismic_tx_with_elements(&setup, plaintext, seismic_elements);
+        let tx_envelope = get_tx_envelope(&setup, tx_seismic);
+        let recovered = Recovered::new_unchecked(&tx_envelope, setup.signer);
+
+        let result = executor.execute_transaction(recovered);
+        assert!(
+            result.is_ok(),
+            "transaction at exact expiry block should be accepted, got: {:?}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_tx_one_block_past_expiry_rejected() {
+        let db = InMemoryDB::default();
+        let mut state = StateBuilder::new_with_database(db).build();
+
+        let setup = setup_test(&mut state);
+
+        // Set block number to one past expires_at_block
+        let mut block_env = BlockEnv::default();
+        block_env.number = U256::from(101);
+
+        let evm = setup.evm_factory.create_evm(
+            &mut state,
+            EvmEnv::new(CfgEnv::new_with_spec(SeismicSpecId::MERCURY), block_env),
+        );
+        let mut executor = setup.executor_factory.create_executor(evm, setup.ctx.clone());
+
+        let plaintext = "hello world";
+        let seismic_elements = TxSeismicElements {
+            encryption_pubkey: setup.encryption_pubkey,
+            encryption_nonce: U96::from_be_slice(&setup.encryption_nonce.0),
+            message_version: 0,
+            recent_block_hash: alloy_primitives::B256::from_slice(&[1u8; 32]),
+            expires_at_block: 100,
+            signed_read: false,
+        };
+        let tx_seismic = sample_seismic_tx_with_elements(&setup, plaintext, seismic_elements);
+        let tx_envelope = get_tx_envelope(&setup, tx_seismic);
+        let recovered = Recovered::new_unchecked(&tx_envelope, setup.signer);
+
+        let result = executor.execute_transaction(recovered);
+        assert!(
+            result.is_err(),
+            "transaction one block past expiry should be rejected, but it was accepted"
+        );
+    }
 }