From 3279267e95c631a9cfaee3ce60437ca0eda73f91 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 23 Apr 2025 12:54:50 -0400 Subject: [PATCH 1/2] feat: system logs --- crates/evm/src/driver.rs | 47 ++++++++++++++++------ crates/evm/src/lib.rs | 2 + crates/evm/src/sys_log.rs | 85 +++++++++++++++++++++++++++++++++++++++ crates/types/Cargo.toml | 1 - 4 files changed, 122 insertions(+), 13 deletions(-) create mode 100644 crates/evm/src/sys_log.rs diff --git a/crates/evm/src/driver.rs b/crates/evm/src/driver.rs index 2be197f..d41215f 100644 --- a/crates/evm/src/driver.rs +++ b/crates/evm/src/driver.rs @@ -21,11 +21,11 @@ use reth::{ Inspector, }, }; -use signet_extract::Extracts; +use signet_extract::{ExtractedEvent, Extracts}; use signet_types::{config::SignetSystemConstants, AggregateFills, MarketError}; -use signet_zenith::MINTER_ADDRESS; +use signet_zenith::{Passage, Transactor, MINTER_ADDRESS}; use std::collections::{HashSet, VecDeque}; -use tracing::{debug, debug_span, trace_span, warn}; +use tracing::{debug, debug_span, warn}; use trevm::{ fillers::{DisableGasChecks, DisableNonceCheck}, helpers::Ctx, @@ -44,16 +44,16 @@ macro_rules! run_tx { ($self:ident, $trevm:ident, $tx:expr, $sender:expr) => {{ let trevm = $trevm.fill_tx($tx); - let _guard = trace_span!("run_tx", block_env = ?trevm.block(), tx = ?$tx, tx_env = ?trevm.tx(), spec_id = ?trevm.spec_id()).entered(); + let _guard = tracing::trace_span!("run_tx", block_env = ?trevm.block(), tx = ?$tx, tx_env = ?trevm.tx(), spec_id = ?trevm.spec_id()).entered(); match trevm.run() { Ok(t) => { - debug!("evm executed successfully"); + tracing::debug!("evm executed successfully"); ControlFlow::Keep(t) }, Err(e) => { if e.is_transaction_error() { - debug!( + tracing::debug!( err = %e.as_transaction_error().unwrap(), "Discarding outcome due to execution error" ); @@ -384,9 +384,15 @@ impl<'a, 'b> SignetDriver<'a, 'b> { } /// Make a receipt for an enter. - fn make_enter_receipt(&self) -> alloy::consensus::Receipt { + fn make_enter_receipt( + &self, + enter: &ExtractedEvent<'_, Passage::Enter>, + ) -> alloy::consensus::Receipt { let cumulative_gas_used = self.cumulative_gas_used().saturating_add(BASE_GAS as u64); - alloy::consensus::Receipt { status: true.into(), cumulative_gas_used, logs: vec![] } + + let sys_log = crate::sys_log::Enter::from(enter).to_sys_log(); + + alloy::consensus::Receipt { status: true.into(), cumulative_gas_used, logs: vec![sys_log] } } /// Construct a block header for DB and evm execution. @@ -429,6 +435,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { &mut self, mut trevm: EvmTransacted, tx: TransactionSigned, + extract: Option<&ExtractedEvent<'_, Transactor::Transact>>, ) -> RunTxResult where Db: Database + DatabaseCommit, @@ -446,6 +453,14 @@ impl<'a, 'b> SignetDriver<'a, 'b> { return Ok(trevm.reject()); } + if let ExecutionResult::Success { logs, .. } = trevm.result_mut_unchecked() { + if let Some(extract) = extract { + // Push the sys_log to the outcome + let sys_log = crate::sys_log::Transact::from(extract).to_sys_log(); + logs.push(sys_log); + } + } + // We track this separately from the cumulative gas used. Enters and // EnterTokens are not payable, so we don't want to include their gas // usage in the payable gas used. @@ -518,7 +533,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { s.record("sender", sender.to_string()); // Run the tx, returning from this function if there is a tx error let t = run_tx_early_return!(self, trevm, &FillShim(&tx, sender), sender); - trevm = self.check_fills_and_accept(t, tx)?; + trevm = self.check_fills_and_accept(t, tx, None)?; } else { warn!("Failed to recover signer for transaction"); } @@ -580,7 +595,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { // push receipt and transaction to the block self.processed.push(Enter { enter, nonce }.to_reth()); self.output.push_result( - ReceiptEnvelope::Eip1559(self.make_enter_receipt().into()), + ReceiptEnvelope::Eip1559(self.make_enter_receipt(enter).into()), MINTER_ADDRESS, ); @@ -632,7 +647,15 @@ impl<'a, 'b> SignetDriver<'a, 'b> { token: ru_token_addr, }; - let t = run_tx_early_return!(self, trevm, &to_execute, MINTER_ADDRESS); + let mut t = run_tx_early_return!(self, trevm, &to_execute, MINTER_ADDRESS); + + // push a sys_log to the outcome + if let ExecutionResult::Success { logs, .. } = t.result_mut_unchecked() { + let sys_log = + crate::sys_log::EnterToken::from(&self.extracts.enter_tokens[idx]).to_sys_log(); + logs.push(sys_log) + } + // No need to check AggregateFills. This call cannot result in orders. Ok(self.accept_tx(t, to_execute.to_reth())) } @@ -739,7 +762,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { } } - self.check_fills_and_accept(t, to_execute.to_reth()) + self.check_fills_and_accept(t, to_execute.to_reth(), Some(&self.extracts.transacts[idx])) } /// Execute all transact events. diff --git a/crates/evm/src/lib.rs b/crates/evm/src/lib.rs index 15c8faa..d516690 100644 --- a/crates/evm/src/lib.rs +++ b/crates/evm/src/lib.rs @@ -39,6 +39,8 @@ use trevm::{ TrevmBuilder, }; +mod sys_log; + pub(crate) const BASE_GAS: usize = 21_000; /// Type alias for EVMs using a [`StateProviderBox`] as the `DB` type for diff --git a/crates/evm/src/sys_log.rs b/crates/evm/src/sys_log.rs new file mode 100644 index 0000000..410efc9 --- /dev/null +++ b/crates/evm/src/sys_log.rs @@ -0,0 +1,85 @@ +use alloy::{primitives::Log, sol_types::SolEvent}; +use signet_extract::ExtractedEvent; +use signet_zenith::{Passage, Transactor, MINTER_ADDRESS}; + +alloy::sol! { + event Enter( + bytes32 indexed txHash, + uint64 indexed logIndex, + address indexed recipient, + uint256 amount, + ); + + event EnterToken( + bytes32 indexed txHash, + uint64 indexed logIndex, + address indexed recipient, + address token, + uint256 amount, + ); + + event Transact( + bytes32 indexed txHash, + uint64 indexed logIndex, + address indexed sender, + uint256 value, + uint256 gas, + uint256 maxFeePerGas, + ); +} + +impl From<&ExtractedEvent<'_, Passage::Enter>> for Enter { + fn from(event: &ExtractedEvent<'_, Passage::Enter>) -> Self { + Enter { + recipient: event.event.rollupRecipient, + txHash: event.tx_hash(), + logIndex: event.log_index as u64, + amount: event.amount(), + } + } +} + +impl Enter { + /// Convert this event to a system log. + pub fn to_sys_log(self) -> Log { + Log { address: MINTER_ADDRESS, data: self.encode_log_data() } + } +} + +impl From<&ExtractedEvent<'_, Passage::EnterToken>> for EnterToken { + fn from(event: &ExtractedEvent<'_, Passage::EnterToken>) -> Self { + EnterToken { + recipient: event.event.rollupRecipient, + txHash: event.tx_hash(), + logIndex: event.log_index as u64, + token: event.token(), + amount: event.amount(), + } + } +} +impl EnterToken { + /// Convert this event to a system log. + pub fn to_sys_log(self) -> Log { + Log { address: MINTER_ADDRESS, data: self.encode_log_data() } + } +} + +impl From<&ExtractedEvent<'_, Transactor::Transact>> for Transact { + fn from(event: &ExtractedEvent<'_, Transactor::Transact>) -> Self { + Transact { + sender: event.event.sender, + txHash: event.tx_hash(), + logIndex: event.log_index as u64, + value: event.value(), + gas: event.event.gas, + maxFeePerGas: event.event.maxFeePerGas, + } + } +} + +impl Transact { + /// Convert this event to a system log. + pub fn to_sys_log(self) -> Log { + Log { address: MINTER_ADDRESS, data: self.encode_log_data() } + } +} diff --git a/crates/types/Cargo.toml b/crates/types/Cargo.toml index d893d01..2158c94 100644 --- a/crates/types/Cargo.toml +++ b/crates/types/Cargo.toml @@ -22,7 +22,6 @@ chrono.workspace = true [dev-dependencies] tokio = { version = "1.37.0", features = ["macros"] } - [features] default = [] test-utils = [] From e876d50e986001043543afa4b5e42a54a84470b2 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 23 Apr 2025 13:53:03 -0400 Subject: [PATCH 2/2] refactor: use from/to --- crates/evm/src/driver.rs | 7 +++---- crates/evm/src/sys_log.rs | 22 ++++++++++------------ 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/crates/evm/src/driver.rs b/crates/evm/src/driver.rs index d41215f..21e8528 100644 --- a/crates/evm/src/driver.rs +++ b/crates/evm/src/driver.rs @@ -390,7 +390,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { ) -> alloy::consensus::Receipt { let cumulative_gas_used = self.cumulative_gas_used().saturating_add(BASE_GAS as u64); - let sys_log = crate::sys_log::Enter::from(enter).to_sys_log(); + let sys_log = crate::sys_log::Enter::from(enter).into(); alloy::consensus::Receipt { status: true.into(), cumulative_gas_used, logs: vec![sys_log] } } @@ -456,7 +456,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { if let ExecutionResult::Success { logs, .. } = trevm.result_mut_unchecked() { if let Some(extract) = extract { // Push the sys_log to the outcome - let sys_log = crate::sys_log::Transact::from(extract).to_sys_log(); + let sys_log = crate::sys_log::Transact::from(extract).into(); logs.push(sys_log); } } @@ -651,8 +651,7 @@ impl<'a, 'b> SignetDriver<'a, 'b> { // push a sys_log to the outcome if let ExecutionResult::Success { logs, .. } = t.result_mut_unchecked() { - let sys_log = - crate::sys_log::EnterToken::from(&self.extracts.enter_tokens[idx]).to_sys_log(); + let sys_log = crate::sys_log::EnterToken::from(&self.extracts.enter_tokens[idx]).into(); logs.push(sys_log) } diff --git a/crates/evm/src/sys_log.rs b/crates/evm/src/sys_log.rs index 410efc9..97b96b3 100644 --- a/crates/evm/src/sys_log.rs +++ b/crates/evm/src/sys_log.rs @@ -39,10 +39,9 @@ impl From<&ExtractedEvent<'_, Passage::Enter>> for Enter { } } -impl Enter { - /// Convert this event to a system log. - pub fn to_sys_log(self) -> Log { - Log { address: MINTER_ADDRESS, data: self.encode_log_data() } +impl From for Log { + fn from(value: Enter) -> Self { + Log { address: MINTER_ADDRESS, data: value.encode_log_data() } } } @@ -57,10 +56,10 @@ impl From<&ExtractedEvent<'_, Passage::EnterToken>> for EnterToken { } } } -impl EnterToken { - /// Convert this event to a system log. - pub fn to_sys_log(self) -> Log { - Log { address: MINTER_ADDRESS, data: self.encode_log_data() } + +impl From for Log { + fn from(value: EnterToken) -> Self { + Log { address: MINTER_ADDRESS, data: value.encode_log_data() } } } @@ -77,9 +76,8 @@ impl From<&ExtractedEvent<'_, Transactor::Transact>> for Transact { } } -impl Transact { - /// Convert this event to a system log. - pub fn to_sys_log(self) -> Log { - Log { address: MINTER_ADDRESS, data: self.encode_log_data() } +impl From for Log { + fn from(value: Transact) -> Self { + Log { address: MINTER_ADDRESS, data: value.encode_log_data() } } }