Merge branch 'main' into osiris/tests

README.md

@@ -15,8 +15,6 @@ The PBH payload contains the following fields:
 
 `external_nullifier` - A string containing a prefix, the date marker, and the pbh nonce
 
-`external_nullifier_hash` - The hash of the external nullifier
-
 `nullifier_hash` - A nullifier hash used to keep track of previously used pbh transactions
 
 `root` - The root of the merkle tree for which this proof was generated

world-chain-builder/src/e2e_tests/mod.rs

@@ -168,7 +168,7 @@ impl WorldChainBuilderTestContext {
         let raw_tx = envelope.encoded_2718();
         let mut data = raw_tx.as_ref();
         let recovered = PooledTransactionsElement::decode_enveloped(&mut data).unwrap();
-        let proof = self.valid_proof(
+        let pbh_payload = self.valid_proof(
             signer.address(),
             recovered.hash().as_slice(),
             chrono::Utc::now(),
@@ -177,7 +177,7 @@ impl WorldChainBuilderTestContext {
 
         let world_chain_pooled_tx_element = WorldChainPooledTransactionsElement {
             inner: recovered,
-            semaphore_proof: Some(proof.clone()),
+            pbh_payload: Some(pbh_payload.clone()),
         };
 
         let mut buff = Vec::<u8>::new();

world-chain-builder/src/node/test_utils.rs

@@ -599,9 +599,9 @@ where
         _origin: TransactionOrigin,
         transaction: Self::Transaction,
     ) -> TransactionValidationOutcome<Self::Transaction> {
-        if let Some(semaphore_proof) = transaction.pbh_payload() {
+        if let Some(pbh_paylaod) = transaction.pbh_payload() {
             self.inner
-                .set_validated(&transaction, semaphore_proof)
+                .set_validated(&transaction, pbh_paylaod)
                 .expect("Error when writing to the db");
         }
 

world-chain-builder/src/payload/builder.rs

@@ -760,7 +760,7 @@ mod tests {
         );
 
         let wc_noop_validator = WorldChainNoopValidator::new(wc_validator);
-        let ordering = WorldChainOrdering::new(db.clone());
+        let ordering = WorldChainOrdering::default();
 
         let world_chain_tx_pool = reth::transaction_pool::Pool::new(
             wc_noop_validator,
@@ -876,7 +876,7 @@ mod tests {
         );
 
         let wc_noop_validator = WorldChainNoopValidator::new(wc_validator);
-        let ordering = WorldChainOrdering::new(db.clone());
+        let ordering = WorldChainOrdering::default();
 
         let world_chain_tx_pool = reth::transaction_pool::Pool::new(
             wc_noop_validator,
@@ -1030,15 +1030,15 @@ mod tests {
                 );
                 let pooled_tx = EthPooledTransaction::new(tx_recovered.clone(), 200);
 
-                let semaphore_proof = if pbh {
+                let pbh_payload = if pbh {
                     Some(PbhPayload::default())
                 } else {
                     None
                 };
 
                 WorldChainPooledTransaction {
                     inner: pooled_tx,
-                    semaphore_proof,
+                    pbh_payload,
                 }
             })
             .collect::<Vec<_>>()

world-chain-builder/src/pbh/db.rs

@@ -14,9 +14,12 @@ use serde::{Deserialize, Serialize};
 use tracing::info;
 
 use reth_db::cursor::DbCursorRW;
-use reth_db::transaction::{DbTx, DbTxMut};
+use reth_db::transaction::DbTxMut;
 
 /// Table for executed nullifiers.
+///
+/// This table stores the nullifiers of PBH transactions that have been
+/// included into a block after it has been sealed.
 #[derive(Debug, Clone, Default)]
 pub struct ExecutedPbhNullifierTable;
 
@@ -29,6 +32,11 @@ impl Table for ExecutedPbhNullifierTable {
 }
 
 /// Table to store PBH validated transactions along with their nullifiers.
+///
+/// When a trasnaction is validated before being inserted into the pool,
+/// a mapping is created from the transaction hash to the nullifier here.
+/// This is primarily used as a caching mechanism to avoid certain types of
+/// DoS attacks.
 #[derive(Debug, Clone, Default)]
 pub struct ValidatedPbhTransactionTable;
 
@@ -55,15 +63,6 @@ impl Compress for EmptyValue {
     fn compress_to_buf<B: BufMut + AsMut<[u8]>>(self, _buf: &mut B) {}
 }
 
-/// Check the database to see if a tx has been validated for PBH
-/// If so return the nullifier
-pub fn get_pbh_validated(
-    db_tx: Tx<RW>,
-    tx: TxHash,
-) -> Result<Option<FixedBytes<32>>, DatabaseError> {
-    db_tx.get::<ValidatedPbhTransactionTable>(tx)
-}
-
 /// Set the store the nullifier for a tx after it
 /// has been included in the block
 /// don't forget to call db_tx.commit() at the very end

world-chain-builder/src/pbh/payload.rs

@@ -77,15 +77,15 @@ mod test {
             ),
             (U256::from(7u64), U256::from(8u64)),
         ));
-        let semaphore_proof = PbhPayload {
+        let pbh_payload = PbhPayload {
             external_nullifier: "0-012025-11".to_string(),
             nullifier_hash: Field::from(10u64),
             root: Field::from(12u64),
             proof,
         };
-        let encoded = alloy_rlp::encode(&semaphore_proof);
+        let encoded = alloy_rlp::encode(&pbh_payload);
         let mut buf = encoded.as_slice();
         let decoded = PbhPayload::decode(&mut buf).unwrap();
-        assert_eq!(semaphore_proof, decoded);
+        assert_eq!(pbh_payload, decoded);
     }
 }

world-chain-builder/src/pool/builder.rs

@@ -65,7 +65,7 @@ where
             )
         });
 
-        let ordering = WorldChainOrdering::new(self.db.clone());
+        let ordering = WorldChainOrdering::default();
 
         let transaction_pool =
             reth::transaction_pool::Pool::new(validator, ordering, blob_store, ctx.pool_config());

world-chain-builder/src/pool/ordering.rs

@@ -1,20 +1,14 @@
 use super::tx::WorldChainPoolTransaction;
-use crate::pbh::db::ValidatedPbhTransactionTable;
 use reth::transaction_pool::{CoinbaseTipOrdering, Priority, TransactionOrdering};
-use reth_db::transaction::DbTx;
-use reth_db::{Database as _, DatabaseEnv, DatabaseError};
 use revm_primitives::U256;
-use std::sync::Arc;
 
 /// Default ordering for the pool.
 ///
 /// The transactions are ordered by their coinbase tip.
 /// The higher the coinbase tip is, the higher the priority of the transaction.
 #[derive(Debug)]
-#[non_exhaustive]
 pub struct WorldChainOrdering<T> {
     inner: CoinbaseTipOrdering<T>,
-    pbh_db: Arc<DatabaseEnv>,
 }
 
 /// Ordering is automatically derived.
@@ -26,31 +20,6 @@ pub struct WorldChainPriority {
     effective_tip_per_gas: Option<U256>,
 }
 
-impl<T> WorldChainOrdering<T>
-where
-    T: WorldChainPoolTransaction + 'static,
-{
-    /// Create a new [`WorldChainOrdering`].
-    pub fn new(database_env: Arc<DatabaseEnv>) -> Self {
-        Self {
-            inner: CoinbaseTipOrdering::default(),
-            pbh_db: database_env,
-        }
-    }
-    fn try_is_pbh(&self, transaction: &T) -> Result<bool, DatabaseError> {
-        let db_tx = self.pbh_db.tx()?;
-        Ok(db_tx
-            .get::<ValidatedPbhTransactionTable>(*transaction.hash())?
-            .is_some())
-    }
-    fn is_pbh(&self, transaction: &T) -> bool {
-        self.try_is_pbh(transaction).unwrap_or_else(|error| {
-            tracing::error!(?error, "Failed to load transaction from database");
-            false
-        })
-    }
-}
-
 impl<T> TransactionOrdering for WorldChainOrdering<T>
 where
     T: WorldChainPoolTransaction + 'static,
@@ -64,9 +33,9 @@ where
         base_fee: u64,
     ) -> Priority<Self::PriorityValue> {
         let effective_tip_per_gas = transaction.effective_tip_per_gas(base_fee).map(U256::from);
-        let is_pbh = self.is_pbh(transaction);
+
         Some(WorldChainPriority {
-            is_pbh,
+            is_pbh: transaction.pbh_payload().is_some(),
             effective_tip_per_gas,
         })
         .into()
@@ -77,7 +46,14 @@ impl<T> Clone for WorldChainOrdering<T> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
-            pbh_db: self.pbh_db.clone(),
+        }
+    }
+}
+
+impl<T> Default for WorldChainOrdering<T> {
+    fn default() -> Self {
+        Self {
+            inner: CoinbaseTipOrdering::default(),
         }
     }
 }

world-chain-builder/src/pool/tx.rs

@@ -14,7 +14,7 @@ pub trait WorldChainPoolTransaction: EthPoolTransaction {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct WorldChainPooledTransaction {
     pub inner: EthPooledTransaction,
-    pub semaphore_proof: Option<PbhPayload>,
+    pub pbh_payload: Option<PbhPayload>,
 }
 
 impl EthPoolTransaction for WorldChainPooledTransaction {
@@ -41,7 +41,7 @@ impl EthPoolTransaction for WorldChainPooledTransaction {
 
 impl WorldChainPoolTransaction for WorldChainPooledTransaction {
     fn pbh_payload(&self) -> Option<&PbhPayload> {
-        self.semaphore_proof.as_ref()
+        self.pbh_payload.as_ref()
     }
 }
 
@@ -57,7 +57,7 @@ impl TryFrom<TransactionSignedEcRecovered> for WorldChainPooledTransaction {
     fn try_from(tx: TransactionSignedEcRecovered) -> Result<Self, Self::Error> {
         Ok(Self {
             inner: EthPooledTransaction::try_from(tx)?,
-            semaphore_proof: None,
+            pbh_payload: None,
         })
     }
 }
@@ -66,7 +66,7 @@ impl From<WorldChainPooledTransactionsElementEcRecovered> for WorldChainPooledTr
     fn from(tx: WorldChainPooledTransactionsElementEcRecovered) -> Self {
         Self {
             inner: EthPooledTransaction::from_pooled(tx.inner),
-            semaphore_proof: tx.semaphore_proof,
+            pbh_payload: tx.pbh_payload,
         }
     }
 }
@@ -77,7 +77,7 @@ impl From<PooledTransactionsElementEcRecovered> for WorldChainPooledTransactions
             inner: value,
             // Incoming consensus transactions do not have a semaphore proof
             // Is this problematic?
-            semaphore_proof: None,
+            pbh_payload: None,
         }
     }
 }
@@ -98,7 +98,7 @@ impl PoolTransaction for WorldChainPooledTransaction {
     fn try_from_consensus(tx: Self::Consensus) -> Result<Self, Self::TryFromConsensusError> {
         EthPooledTransaction::try_from_consensus(tx).map(|inner| Self {
             inner,
-            semaphore_proof: None,
+            pbh_payload: None,
         })
     }