diff --git a/crates/evm/src/driver.rs b/crates/evm/src/driver.rs index 2be197f..21e8528 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).into(); + + 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).into(); + 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,14 @@ 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]).into(); + 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 +761,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..97b96b3 --- /dev/null +++ b/crates/evm/src/sys_log.rs @@ -0,0 +1,83 @@ +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 From for Log { + fn from(value: Enter) -> Self { + Log { address: MINTER_ADDRESS, data: value.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 From for Log { + fn from(value: EnterToken) -> Self { + Log { address: MINTER_ADDRESS, data: value.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 From for Log { + fn from(value: Transact) -> Self { + Log { address: MINTER_ADDRESS, data: value.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 = []