feat: send bytecode with call input (#2963)

rakita · web-flow · commit 24f92566dee2 · 2025-09-17T12:35:44.000+02:00
* feat: send bytecode with call input

* load acc first

* inline calls

* use

* never inline few fn

* inline load code

* load account

* inline only

* now we can do unsafe transfer

* handle same address transfer, and zero balance

* rm get_many_mut and optimize inlining

* revert inlines

* inline load_account_info_skip_cold_load

* use old transfer

* use transfer_loaded

* never inline call helper

* bytecode is always some in CallInput
diff --git a/crates/context/interface/src/journaled_state.rs b/crates/context/interface/src/journaled_state.rs
@@ -125,6 +125,14 @@ pub trait JournalTr {
         balance: U256,
     ) -> Result<Option<TransferError>, <Self::Database as Database>::Error>;
 
+    /// Transfers the balance from one account to another. Assume form and to are loaded.
+    fn transfer_loaded(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Option<TransferError>;
+
     /// Increments the balance of the account.
     fn caller_accounting_journal_entry(
         &mut self,
diff --git a/crates/context/src/journal.rs b/crates/context/src/journal.rs
@@ -195,6 +195,16 @@ impl<DB: Database, ENTRY: JournalEntryTr> JournalTr for Journal<DB, ENTRY> {
         self.inner.transfer(&mut self.database, from, to, balance)
     }
 
+    #[inline]
+    fn transfer_loaded(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Option<TransferError> {
+        self.inner.transfer_loaded(from, to, balance)
+    }
+
     #[inline]
     fn touch_account(&mut self, address: Address) {
         self.inner.touch(address);
@@ -304,6 +314,7 @@ impl<DB: Database, ENTRY: JournalEntryTr> JournalTr for Journal<DB, ENTRY> {
         self.inner.finalize()
     }
 
+    #[inline]
     fn sload_skip_cold_load(
         &mut self,
         address: Address,
@@ -315,6 +326,7 @@ impl<DB: Database, ENTRY: JournalEntryTr> JournalTr for Journal<DB, ENTRY> {
             .sload(&mut self.database, address, key, skip_cold_load)
     }
 
+    #[inline]
     fn sstore_skip_cold_load(
         &mut self,
         address: Address,
diff --git a/crates/context/src/journal/inner.rs b/crates/context/src/journal/inner.rs
@@ -315,6 +315,59 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
         self.journal.push(ENTRY::nonce_changed(address));
     }
 
+    /// Transfers balance from two accounts. Returns error if sender balance is not enough.
+    ///
+    /// # Panics
+    ///
+    /// Panics if from or to are not loaded.
+    #[inline]
+    pub fn transfer_loaded(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Option<TransferError> {
+        if from == to {
+            let from_balance = self.state.get_mut(&to).unwrap().info.balance;
+            // Check if from balance is enough to transfer the balance.
+            if balance > from_balance {
+                return Some(TransferError::OutOfFunds);
+            }
+            return None;
+        }
+
+        if balance.is_zero() {
+            Self::touch_account(&mut self.journal, to, self.state.get_mut(&to).unwrap());
+            return None;
+        }
+
+        // sub balance from
+        let from_account = self.state.get_mut(&from).unwrap();
+        // no need to touch caller account.
+        // Self::touch_account(&mut self.journal, from, from_account);
+        let from_balance = &mut from_account.info.balance;
+        let Some(from_balance_decr) = from_balance.checked_sub(balance) else {
+            return Some(TransferError::OutOfFunds);
+        };
+        *from_balance = from_balance_decr;
+
+        // add balance to
+        let to_account = self.state.get_mut(&to).unwrap();
+        Self::touch_account(&mut self.journal, to, to_account);
+        let to_balance = &mut to_account.info.balance;
+        let Some(to_balance_incr) = to_balance.checked_add(balance) else {
+            // Overflow of U256 balance is not possible to happen on mainnet. We don't bother to return funds from from_acc.
+            return Some(TransferError::OverflowPayment);
+        };
+        *to_balance = to_balance_incr;
+
+        // add journal entry
+        self.journal
+            .push(ENTRY::balance_transfer(from, to, balance));
+
+        None
+    }
+
     /// Transfers balance from two accounts. Returns error if sender balance is not enough.
     #[inline]
     pub fn transfer<DB: Database>(
@@ -349,10 +402,10 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
         Self::touch_account(&mut self.journal, to, to_account);
         let to_balance = &mut to_account.info.balance;
         let Some(to_balance_incr) = to_balance.checked_add(balance) else {
+            // Overflow of U256 balance is not possible to happen on mainnet. We don't bother to return funds from from_acc.
             return Ok(Some(TransferError::OverflowPayment));
         };
         *to_balance = to_balance_incr;
-        // Overflow of U256 balance is not possible to happen on mainnet. We don't bother to return funds from from_acc.
 
         self.journal
             .push(ENTRY::balance_transfer(from, to, balance));
@@ -600,7 +653,9 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
         // load delegate code if account is EIP-7702
         if let Some(Bytecode::Eip7702(code)) = &account.info.code {
             let address = code.address();
-            let delegate_account = self.load_account(db, address)?;
+            let delegate_account = self
+                .load_account_optional(db, address, true, [], false)
+                .map_err(JournalLoadError::unwrap_db_error)?;
             account_load.data.is_delegate_account_cold = Some(delegate_account.is_cold);
         }
 
diff --git a/crates/handler/src/execution.rs b/crates/handler/src/execution.rs
@@ -2,25 +2,36 @@ use context_interface::Transaction;
 use interpreter::{
     CallInput, CallInputs, CallScheme, CallValue, CreateInputs, CreateScheme, FrameInput,
 };
-use primitives::TxKind;
+use primitives::{TxKind, B256};
+use state::Bytecode;
 use std::boxed::Box;
 
 /// Creates the first [`FrameInput`] from the transaction, spec and gas limit.
-pub fn create_init_frame(tx: &impl Transaction, gas_limit: u64) -> FrameInput {
+#[inline]
+pub fn create_init_frame(
+    tx: &impl Transaction,
+    bytecode: Option<(Bytecode, B256)>,
+    gas_limit: u64,
+) -> FrameInput {
     let input = tx.input().clone();
 
     match tx.kind() {
-        TxKind::Call(target_address) => FrameInput::Call(Box::new(CallInputs {
-            input: CallInput::Bytes(input),
-            gas_limit,
-            target_address,
-            bytecode_address: target_address,
-            caller: tx.caller(),
-            value: CallValue::Transfer(tx.value()),
-            scheme: CallScheme::Call,
-            is_static: false,
-            return_memory_offset: 0..0,
-        })),
+        TxKind::Call(target_address) => {
+            let (bytecode, bytecode_hash) = bytecode.unwrap_or_default();
+            FrameInput::Call(Box::new(CallInputs {
+                input: CallInput::Bytes(input),
+                gas_limit,
+                target_address,
+                bytecode_address: target_address,
+                bytecode,
+                bytecode_hash,
+                caller: tx.caller(),
+                value: CallValue::Transfer(tx.value()),
+                scheme: CallScheme::Call,
+                is_static: false,
+                return_memory_offset: 0..0,
+            }))
+        }
         TxKind::Create => FrameInput::Create(Box::new(CreateInputs {
             caller: tx.caller(),
             scheme: CreateScheme::Create,
diff --git a/crates/handler/src/frame.rs b/crates/handler/src/frame.rs
@@ -163,11 +163,6 @@ impl EthFrame<EthInterpreter> {
             return return_result(InstructionResult::CallTooDeep);
         }
 
-        // Make account warm and loaded.
-        let _ = ctx
-            .journal_mut()
-            .load_account_delegated(inputs.bytecode_address)?;
-
         // Create subroutine checkpoint
         let checkpoint = ctx.journal_mut().checkpoint();
 
@@ -177,7 +172,7 @@ impl EthFrame<EthInterpreter> {
             // Target will get touched even if balance transferred is zero.
             if let Some(i) =
                 ctx.journal_mut()
-                    .transfer(inputs.caller, inputs.target_address, value)?
+                    .transfer_loaded(inputs.caller, inputs.target_address, value)
             {
                 ctx.journal_mut().checkpoint_revert(checkpoint);
                 return return_result(i.into());
@@ -206,21 +201,8 @@ impl EthFrame<EthInterpreter> {
             })));
         }
 
-        let account = ctx
-            .journal_mut()
-            .load_account_code(inputs.bytecode_address)?;
-
-        let mut code_hash = account.info.code_hash();
-        let mut bytecode = account.info.code.clone().unwrap_or_default();
-
-        if let Bytecode::Eip7702(eip7702_bytecode) = bytecode {
-            let account = &ctx
-                .journal_mut()
-                .load_account_code(eip7702_bytecode.delegated_address)?
-                .info;
-            bytecode = account.code.clone().unwrap_or_default();
-            code_hash = account.code_hash();
-        }
+        let bytecode = inputs.bytecode.clone();
+        let bytecode_hash = inputs.bytecode_hash;
 
         // Returns success if bytecode is empty.
         if bytecode.is_empty() {
@@ -236,7 +218,7 @@ impl EthFrame<EthInterpreter> {
             FrameInput::Call(inputs),
             depth,
             memory,
-            ExtBytecode::new_with_hash(bytecode, code_hash),
+            ExtBytecode::new_with_hash(bytecode, bytecode_hash),
             interpreter_input,
             is_static,
             ctx.cfg().spec().into(),
@@ -275,12 +257,6 @@ impl EthFrame<EthInterpreter> {
             return return_error(InstructionResult::CallTooDeep);
         }
 
-        // Prague EOF
-        // TODO(EOF)
-        // if spec.is_enabled_in(OSAKA) && inputs.init_code.starts_with(&EOF_MAGIC_BYTES) {
-        //     return return_error(InstructionResult::CreateInitCodeStartingEF00);
-        // }
-
         // Fetch balance of caller.
         let caller_info = &mut context.journal_mut().load_account(inputs.caller)?.data.info;
 
diff --git a/crates/handler/src/handler.rs b/crates/handler/src/handler.rs
@@ -13,6 +13,7 @@ use context_interface::{
 use interpreter::interpreter_action::FrameInit;
 use interpreter::{Gas, InitialAndFloorGas, SharedMemory};
 use primitives::U256;
+use state::Bytecode;
 
 /// Trait for errors that can occur during EVM execution.
 ///
@@ -290,13 +291,34 @@ pub trait Handler {
         evm: &mut Self::Evm,
         gas_limit: u64,
     ) -> Result<FrameInit, Self::Error> {
-        let memory =
-            SharedMemory::new_with_buffer(evm.ctx().local().shared_memory_buffer().clone());
-        let ctx = evm.ctx_ref();
+        let ctx = evm.ctx_mut();
+        let memory = SharedMemory::new_with_buffer(ctx.local().shared_memory_buffer().clone());
+
+        let (tx, journal) = ctx.tx_journal_mut();
+        let bytecode = if let Some(&to) = tx.kind().to() {
+            let account = &journal.load_account_code(to)?.info;
+
+            if let Some(Bytecode::Eip7702(eip7702_bytecode)) = &account.code {
+                let delegated_address = eip7702_bytecode.delegated_address;
+                let account = &journal.load_account_code(delegated_address)?.info;
+                Some((
+                    account.code.clone().unwrap_or_default(),
+                    account.code_hash(),
+                ))
+            } else {
+                Some((
+                    account.code.clone().unwrap_or_default(),
+                    account.code_hash(),
+                ))
+            }
+        } else {
+            None
+        };
+
         Ok(FrameInit {
             depth: 0,
             memory,
-            frame_input: execution::create_init_frame(ctx.tx(), gas_limit),
+            frame_input: execution::create_init_frame(tx, bytecode, gas_limit),
         })
     }
 
diff --git a/crates/interpreter/src/instructions/contract.rs b/crates/interpreter/src/instructions/contract.rs
@@ -127,7 +127,7 @@ pub fn call<WIRE: InterpreterTypes, H: Host + ?Sized>(
     else {
         return;
     };
-    let Some(gas_limit) =
+    let Some((gas_limit, bytecode, bytecode_hash)) =
         load_acc_and_calc_gas(&mut context, to, has_transfer, true, local_gas_limit)
     else {
         return;
@@ -144,6 +144,8 @@ pub fn call<WIRE: InterpreterTypes, H: Host + ?Sized>(
                 target_address: to,
                 caller: context.interpreter.input.target_address(),
                 bytecode_address: to,
+                bytecode,
+                bytecode_hash,
                 value: CallValue::Transfer(value),
                 scheme: CallScheme::Call,
                 is_static: context.interpreter.runtime_flag.is_static(),
@@ -169,7 +171,7 @@ pub fn call_code<WIRE: InterpreterTypes, H: Host + ?Sized>(
         return;
     };
 
-    let Some(gas_limit) =
+    let Some((gas_limit, bytecode, bytecode_hash)) =
         load_acc_and_calc_gas(&mut context, to, has_transfer, false, local_gas_limit)
     else {
         return;
@@ -186,6 +188,8 @@ pub fn call_code<WIRE: InterpreterTypes, H: Host + ?Sized>(
                 target_address: context.interpreter.input.target_address(),
                 caller: context.interpreter.input.target_address(),
                 bytecode_address: to,
+                bytecode,
+                bytecode_hash,
                 value: CallValue::Transfer(value),
                 scheme: CallScheme::CallCode,
                 is_static: context.interpreter.runtime_flag.is_static(),
@@ -211,7 +215,8 @@ pub fn delegate_call<WIRE: InterpreterTypes, H: Host + ?Sized>(
         return;
     };
 
-    let Some(gas_limit) = load_acc_and_calc_gas(&mut context, to, false, false, local_gas_limit)
+    let Some((gas_limit, bytecode, bytecode_hash)) =
+        load_acc_and_calc_gas(&mut context, to, false, false, local_gas_limit)
     else {
         return;
     };
@@ -227,6 +232,8 @@ pub fn delegate_call<WIRE: InterpreterTypes, H: Host + ?Sized>(
                 target_address: context.interpreter.input.target_address(),
                 caller: context.interpreter.input.caller_address(),
                 bytecode_address: to,
+                bytecode,
+                bytecode_hash,
                 value: CallValue::Apparent(context.interpreter.input.call_value()),
                 scheme: CallScheme::DelegateCall,
                 is_static: context.interpreter.runtime_flag.is_static(),
@@ -252,7 +259,8 @@ pub fn static_call<WIRE: InterpreterTypes, H: Host + ?Sized>(
         return;
     };
 
-    let Some(gas_limit) = load_acc_and_calc_gas(&mut context, to, false, false, local_gas_limit)
+    let Some((gas_limit, bytecode, bytecode_hash)) =
+        load_acc_and_calc_gas(&mut context, to, false, false, local_gas_limit)
     else {
         return;
     };
@@ -268,6 +276,8 @@ pub fn static_call<WIRE: InterpreterTypes, H: Host + ?Sized>(
                 target_address: to,
                 caller: context.interpreter.input.target_address(),
                 bytecode_address: to,
+                bytecode,
+                bytecode_hash,
                 value: CallValue::Transfer(U256::ZERO),
                 scheme: CallScheme::StaticCall,
                 is_static: true,
diff --git a/crates/interpreter/src/instructions/contract/call_helpers.rs b/crates/interpreter/src/instructions/contract/call_helpers.rs
diff --git a/crates/interpreter/src/interpreter_action/call_inputs.rs b/crates/interpreter/src/interpreter_action/call_inputs.rs
diff --git a/examples/cheatcode_inspector/src/main.rs b/examples/cheatcode_inspector/src/main.rs
