Merge pull request #22 from weaveVM/precompile-infrastructure

feat: Add precompile infrastructure
weaveVM · Aug 1, 2024 · 8175e78 · 8175e78
2 parents 3ddba6e + 92cd4d1
commit 8175e78
Show file tree

Hide file tree

Showing 127 changed files with 1,376 additions and 898 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -146,6 +146,7 @@ members = [
     "wvm-apps/wvm-exexed/crates/repository/",
     "wvm-apps/wvm-exexed/crates/exex-etl/",
     "wvm-apps/wvm-exexed/crates/lambda/",
+    "wvm-apps/wvm-exexed/crates/precompiles/",
     "wvm-apps/wvm-exexed/crates/bigquery/",
     "wvm-apps/wvm-exexed/crates/wevm-borsh/",
     "wvm-apps/wvm-exexed/crates/types/",

diff --git a/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs b/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
@@ -196,8 +196,8 @@ impl Command {
             match (in_mem_updates_iter.next(), incremental_updates_iter.next()) {
                 (Some(in_mem), Some(incr)) => {
                     similar_asserts::assert_eq!(in_mem.0, incr.0, "Nibbles don't match");
-                    if in_mem.1 != incr.1 &&
-                        in_mem.0.len() > self.skip_node_depth.unwrap_or_default()
+                    if in_mem.1 != incr.1
+                        && in_mem.0.len() > self.skip_node_depth.unwrap_or_default()
                     {
                         in_mem_mismatched.push(in_mem);
                         incremental_mismatched.push(incr);

diff --git a/bin/reth/src/commands/debug_cmd/merkle.rs b/bin/reth/src/commands/debug_cmd/merkle.rs
@@ -221,14 +221,14 @@ impl Command {
             let mut clean_account_mismatched = Vec::new();
             let mut incremental_account_trie_iter = incremental_account_trie.into_iter().peekable();
             let mut clean_account_trie_iter = clean_account_trie.into_iter().peekable();
-            while incremental_account_trie_iter.peek().is_some() ||
-                clean_account_trie_iter.peek().is_some()
+            while incremental_account_trie_iter.peek().is_some()
+                || clean_account_trie_iter.peek().is_some()
             {
                 match (incremental_account_trie_iter.next(), clean_account_trie_iter.next()) {
                     (Some(incremental), Some(clean)) => {
                         similar_asserts::assert_eq!(incremental.0, clean.0, "Nibbles don't match");
-                        if incremental.1 != clean.1 &&
-                            clean.0 .0.len() > self.skip_node_depth.unwrap_or_default()
+                        if incremental.1 != clean.1
+                            && clean.0 .0.len() > self.skip_node_depth.unwrap_or_default()
                         {
                             incremental_account_mismatched.push(incremental);
                             clean_account_mismatched.push(clean);
@@ -250,13 +250,13 @@ impl Command {
             let mut first_mismatched_storage = None;
             let mut incremental_storage_trie_iter = incremental_storage_trie.into_iter().peekable();
             let mut clean_storage_trie_iter = clean_storage_trie.into_iter().peekable();
-            while incremental_storage_trie_iter.peek().is_some() ||
-                clean_storage_trie_iter.peek().is_some()
+            while incremental_storage_trie_iter.peek().is_some()
+                || clean_storage_trie_iter.peek().is_some()
             {
                 match (incremental_storage_trie_iter.next(), clean_storage_trie_iter.next()) {
                     (Some(incremental), Some(clean)) => {
-                        if incremental != clean &&
-                            clean.1.nibbles.len() > self.skip_node_depth.unwrap_or_default()
+                        if incremental != clean
+                            && clean.1.nibbles.len() > self.skip_node_depth.unwrap_or_default()
                         {
                             first_mismatched_storage = Some((incremental, clean));
                             break;

diff --git a/bin/reth/src/commands/import.rs b/bin/reth/src/commands/import.rs
@@ -126,8 +126,8 @@ impl ImportCommand {
         let total_imported_blocks = provider.tx_ref().entries::<tables::HeaderNumbers>()?;
         let total_imported_txns = provider.tx_ref().entries::<tables::TransactionHashNumbers>()?;
 
-        if total_decoded_blocks != total_imported_blocks ||
-            total_decoded_txns != total_imported_txns
+        if total_decoded_blocks != total_imported_blocks
+            || total_decoded_txns != total_imported_txns
         {
             error!(target: "reth::cli",
                 total_decoded_blocks,

diff --git a/crates/blockchain-tree-api/src/error.rs b/crates/blockchain-tree-api/src/error.rs
@@ -260,10 +260,10 @@ impl InsertBlockErrorKind {
             Self::Canonical(err) => {
                 matches!(
                     err,
-                    CanonicalError::Validation(BlockValidationError::StateRoot { .. }) |
-                        CanonicalError::Provider(
-                            ProviderError::StateRootMismatch(_) |
-                                ProviderError::UnwindStateRootMismatch(_)
+                    CanonicalError::Validation(BlockValidationError::StateRoot { .. })
+                        | CanonicalError::Provider(
+                            ProviderError::StateRootMismatch(_)
+                                | ProviderError::UnwindStateRootMismatch(_)
                         )
                 )
             }
@@ -292,12 +292,12 @@ impl InsertBlockErrorKind {
                         true
                     }
                     // these are internal errors, not caused by an invalid block
-                    BlockExecutionError::LatestBlock(_) |
-                    BlockExecutionError::Pruning(_) |
-                    BlockExecutionError::CanonicalRevert { .. } |
-                    BlockExecutionError::CanonicalCommit { .. } |
-                    BlockExecutionError::AppendChainDoesntConnect { .. } |
-                    BlockExecutionError::Other(_) => false,
+                    BlockExecutionError::LatestBlock(_)
+                    | BlockExecutionError::Pruning(_)
+                    | BlockExecutionError::CanonicalRevert { .. }
+                    | BlockExecutionError::CanonicalCommit { .. }
+                    | BlockExecutionError::AppendChainDoesntConnect { .. }
+                    | BlockExecutionError::Other(_) => false,
                 }
             }
             Self::Tree(err) => {
@@ -306,24 +306,24 @@ impl InsertBlockErrorKind {
                         // the block's number is lower than the finalized block's number
                         true
                     }
-                    BlockchainTreeError::BlockSideChainIdConsistency { .. } |
-                    BlockchainTreeError::CanonicalChain { .. } |
-                    BlockchainTreeError::BlockNumberNotFoundInChain { .. } |
-                    BlockchainTreeError::BlockHashNotFoundInChain { .. } |
-                    BlockchainTreeError::BlockBufferingFailed { .. } |
-                    BlockchainTreeError::GenesisBlockHasNoParent => false,
+                    BlockchainTreeError::BlockSideChainIdConsistency { .. }
+                    | BlockchainTreeError::CanonicalChain { .. }
+                    | BlockchainTreeError::BlockNumberNotFoundInChain { .. }
+                    | BlockchainTreeError::BlockHashNotFoundInChain { .. }
+                    | BlockchainTreeError::BlockBufferingFailed { .. }
+                    | BlockchainTreeError::GenesisBlockHasNoParent => false,
                 }
             }
             Self::Provider(_) | Self::Internal(_) => {
                 // any other error, such as database errors, are considered internal errors
                 false
             }
             Self::Canonical(err) => match err {
-                CanonicalError::BlockchainTree(_) |
-                CanonicalError::CanonicalCommit(_) |
-                CanonicalError::CanonicalRevert(_) |
-                CanonicalError::OptimisticTargetRevert(_) |
-                CanonicalError::Provider(_) => false,
+                CanonicalError::BlockchainTree(_)
+                | CanonicalError::CanonicalCommit(_)
+                | CanonicalError::CanonicalRevert(_)
+                | CanonicalError::OptimisticTargetRevert(_)
+                | CanonicalError::Provider(_) => false,
                 CanonicalError::Validation(_) => true,
             },
             Self::BlockchainTree(_) => false,

diff --git a/crates/blockchain-tree/src/blockchain_tree.rs b/crates/blockchain-tree/src/blockchain_tree.rs
@@ -1305,8 +1305,8 @@ where
             .provider_factory
             .static_file_provider()
             .get_highest_static_file_block(StaticFileSegment::Headers)
-            .unwrap_or_default() >
-            revert_until
+            .unwrap_or_default()
+            > revert_until
         {
             trace!(
                 target: "blockchain_tree",
@@ -1608,8 +1608,8 @@ mod tests {
                             signer,
                             (
                                 AccountInfo {
-                                    balance: initial_signer_balance -
-                                        (single_tx_cost * U256::from(num_of_signer_txs)),
+                                    balance: initial_signer_balance
+                                        - (single_tx_cost * U256::from(num_of_signer_txs)),
                                     nonce: num_of_signer_txs,
                                     ..Default::default()
                                 },

diff --git a/crates/chainspec/src/spec.rs b/crates/chainspec/src/spec.rs
@@ -333,14 +333,14 @@ impl ChainSpec {
         matches!(
             self.chain.kind(),
             ChainKind::Named(
-                NamedChain::Mainnet |
-                    NamedChain::Morden |
-                    NamedChain::Ropsten |
-                    NamedChain::Rinkeby |
-                    NamedChain::Goerli |
-                    NamedChain::Kovan |
-                    NamedChain::Holesky |
-                    NamedChain::Sepolia
+                NamedChain::Mainnet
+                    | NamedChain::Morden
+                    | NamedChain::Ropsten
+                    | NamedChain::Rinkeby
+                    | NamedChain::Goerli
+                    | NamedChain::Kovan
+                    | NamedChain::Holesky
+                    | NamedChain::Sepolia
             )
         )
     }
@@ -555,8 +555,8 @@ impl ChainSpec {
             // We filter out TTD-based forks w/o a pre-known block since those do not show up in the
             // fork filter.
             Some(match condition {
-                ForkCondition::Block(block) |
-                ForkCondition::TTD { fork_block: Some(block), .. } => ForkFilterKey::Block(block),
+                ForkCondition::Block(block)
+                | ForkCondition::TTD { fork_block: Some(block), .. } => ForkFilterKey::Block(block),
                 ForkCondition::Timestamp(time) => ForkFilterKey::Time(time),
                 _ => return None,
             })
@@ -574,8 +574,8 @@ impl ChainSpec {
         for (_, cond) in self.hardforks.forks_iter() {
             // handle block based forks and the sepolia merge netsplit block edge case (TTD
             // ForkCondition with Some(block))
-            if let ForkCondition::Block(block) |
-            ForkCondition::TTD { fork_block: Some(block), .. } = cond
+            if let ForkCondition::Block(block)
+            | ForkCondition::TTD { fork_block: Some(block), .. } = cond
             {
                 if cond.active_at_head(head) {
                     if block != current_applied {

diff --git a/crates/cli/commands/src/db/stats.rs b/crates/cli/commands/src/db/stats.rs
@@ -271,10 +271,10 @@ impl Command {
                         .add_cell(Cell::new(human_bytes(segment_config_size as f64)));
                 }
                 row.add_cell(Cell::new(human_bytes(
-                    (segment_data_size +
-                        segment_index_size +
-                        segment_offsets_size +
-                        segment_config_size) as f64,
+                    (segment_data_size
+                        + segment_index_size
+                        + segment_offsets_size
+                        + segment_config_size) as f64,
                 )));
                 table.add_row(row);
             }

diff --git a/crates/cli/commands/src/stage/run.rs b/crates/cli/commands/src/stage/run.rs
@@ -155,8 +155,8 @@ impl Command {
                                 config.stages.bodies.downloader_max_buffered_blocks_size_bytes,
                             )
                             .with_concurrent_requests_range(
-                                config.stages.bodies.downloader_min_concurrent_requests..=
-                                    config.stages.bodies.downloader_max_concurrent_requests,
+                                config.stages.bodies.downloader_min_concurrent_requests
+                                    ..=config.stages.bodies.downloader_max_concurrent_requests,
                             )
                             .build(fetch_client, consensus.clone(), provider_factory.clone()),
                     );

diff --git a/crates/consensus/beacon/src/engine/hooks/controller.rs b/crates/consensus/beacon/src/engine/hooks/controller.rs
@@ -136,10 +136,10 @@ impl EngineHooksController {
         // - Active DB write according to passed argument
         // - Missing a finalized block number. We might be on an optimistic sync scenario where we
         // cannot skip the FCU with the finalized hash, otherwise CL might misbehave.
-        if hook.db_access_level().is_read_write() &&
-            (self.active_db_write_hook.is_some() ||
-                db_write_active ||
-                args.finalized_block_number.is_none())
+        if hook.db_access_level().is_read_write()
+            && (self.active_db_write_hook.is_some()
+                || db_write_active
+                || args.finalized_block_number.is_none())
         {
             return Poll::Pending;
         }
@@ -307,9 +307,9 @@ mod tests {
         assert_eq!(
             result.map(|result| {
                 let polled_hook = result.unwrap();
-                polled_hook.name == hook_ro_name &&
-                    polled_hook.event.is_started() &&
-                    polled_hook.db_access_level.is_read_only()
+                polled_hook.name == hook_ro_name
+                    && polled_hook.event.is_started()
+                    && polled_hook.db_access_level.is_read_only()
             }),
             Poll::Ready(true)
         );
@@ -346,9 +346,9 @@ mod tests {
         assert_eq!(
             result.map(|result| {
                 let polled_hook = result.unwrap();
-                polled_hook.name == hook_rw_1_name &&
-                    polled_hook.event.is_started() &&
-                    polled_hook.db_access_level.is_read_write()
+                polled_hook.name == hook_rw_1_name
+                    && polled_hook.event.is_started()
+                    && polled_hook.db_access_level.is_read_write()
             }),
             Poll::Ready(true)
         );
@@ -368,9 +368,9 @@ mod tests {
         assert_eq!(
             result.map(|result| {
                 let polled_hook = result.unwrap();
-                polled_hook.name == hook_ro_name &&
-                    polled_hook.event.is_started() &&
-                    polled_hook.db_access_level.is_read_only()
+                polled_hook.name == hook_ro_name
+                    && polled_hook.event.is_started()
+                    && polled_hook.db_access_level.is_read_only()
             }),
             Poll::Ready(true)
         );

diff --git a/crates/consensus/beacon/src/engine/mod.rs b/crates/consensus/beacon/src/engine/mod.rs
@@ -757,8 +757,8 @@ where
 
             // If current_header is None, then the current_hash does not have an invalid
             // ancestor in the cache, check its presence in blockchain tree
-            if current_header.is_none() &&
-                self.blockchain.find_block_by_hash(current_hash, BlockSource::Any)?.is_some()
+            if current_header.is_none()
+                && self.blockchain.find_block_by_hash(current_hash, BlockSource::Any)?.is_some()
             {
                 return Ok(Some(current_hash));
             }
@@ -857,8 +857,8 @@ where
         //
         // This ensures that the finalized block is consistent with the head block, i.e. the
         // finalized block is an ancestor of the head block.
-        if !state.finalized_block_hash.is_zero() &&
-            !self.blockchain.is_canonical(state.finalized_block_hash)?
+        if !state.finalized_block_hash.is_zero()
+            && !self.blockchain.is_canonical(state.finalized_block_hash)?
         {
             return Ok(Some(OnForkChoiceUpdated::invalid_state()));
         }
@@ -871,8 +871,8 @@ where
         //
         // This ensures that the safe block is consistent with the head block, i.e. the safe
         // block is an ancestor of the head block.
-        if !state.safe_block_hash.is_zero() &&
-            !self.blockchain.is_canonical(state.safe_block_hash)?
+        if !state.safe_block_hash.is_zero()
+            && !self.blockchain.is_canonical(state.safe_block_hash)?
         {
             return Ok(Some(OnForkChoiceUpdated::invalid_state()));
         }
@@ -1255,8 +1255,8 @@ where
                 latest_valid_hash = Some(block_hash);
                 PayloadStatusEnum::Valid
             }
-            InsertPayloadOk::Inserted(BlockStatus::Disconnected { .. }) |
-            InsertPayloadOk::AlreadySeen(BlockStatus::Disconnected { .. }) => {
+            InsertPayloadOk::Inserted(BlockStatus::Disconnected { .. })
+            | InsertPayloadOk::AlreadySeen(BlockStatus::Disconnected { .. }) => {
                 // check if the block's parent is already marked as invalid
                 if let Some(status) =
                     self.check_invalid_ancestor_with_head(block.parent_hash, block.hash()).map_err(

diff --git a/crates/consensus/common/src/validation.rs b/crates/consensus/common/src/validation.rs
@@ -29,8 +29,8 @@ pub fn validate_header_base_fee(
     header: &SealedHeader,
     chain_spec: &ChainSpec,
 ) -> Result<(), ConsensusError> {
-    if chain_spec.is_fork_active_at_block(EthereumHardfork::London, header.number) &&
-        header.base_fee_per_gas.is_none()
+    if chain_spec.is_fork_active_at_block(EthereumHardfork::London, header.number)
+        && header.base_fee_per_gas.is_none()
     {
         return Err(ConsensusError::BaseFeeMissing);
     }