feat: set code hash in pre state

crates/ef-testing/src/evm_sequencer/account/mod.rs

@@ -71,6 +71,7 @@ pub mod kkrt_account {
             _evm_address: &Address,
             _code: &Bytes,
             _nonce: U256,
+            _balance: U256,
             _evm_storage: &[(U256, U256)],
         ) -> Result<Self, StarknetApiError> {
             Ok(Self {

crates/ef-testing/src/evm_sequencer/account/v0.rs

@@ -1,13 +1,16 @@
 use blockifier::abi::{abi_utils::get_storage_var_address, sierra_types::next_storage_key};
+use reth_primitives::alloy_primitives::keccak256;
+use reth_primitives::KECCAK_EMPTY;
 use reth_primitives::{Address, U256};
+
 use revm_interpreter::analysis::to_analysed;
 use revm_primitives::{Bytecode, Bytes};
 use starknet_api::{core::Nonce, state::StorageKey, StarknetApiError};
 use starknet_crypto::Felt;
 
 use super::{pack_byte_array_to_starkfelt_array, KakarotAccount};
 use crate::evm_sequencer::constants::storage_variables::{
-    ACCOUNT_BYTECODE_LEN, ACCOUNT_EVM_ADDRESS, ACCOUNT_IS_INITIALIZED,
+    ACCOUNT_BYTECODE_LEN, ACCOUNT_CODE_HASH, ACCOUNT_EVM_ADDRESS, ACCOUNT_IS_INITIALIZED,
     ACCOUNT_JUMPDESTS_INITIALIZED, ACCOUNT_NONCE, ACCOUNT_STORAGE, ACCOUNT_VALID_JUMPDESTS,
 };
 use crate::evm_sequencer::{types::felt::FeltSequencer, utils::split_u256};
@@ -18,6 +21,7 @@ impl KakarotAccount {
         evm_address: &Address,
         code: &Bytes,
         nonce: U256,
+        balance: U256,
         evm_storage: &[(U256, U256)],
     ) -> Result<Self, StarknetApiError> {
         let nonce = Felt::from(TryInto::<u128>::try_into(nonce).map_err(|err| {
@@ -47,6 +51,25 @@ impl KakarotAccount {
             .collect();
         storage.append(&mut bytecode_storage);
 
+        // Initialize the code hash var
+        let account_is_empty =
+            code.is_empty() && nonce == Felt::from(0) && balance == U256::from(0);
+        let code_hash = if account_is_empty {
+            U256::from(0)
+        } else if code.is_empty() {
+            U256::from_be_slice(KECCAK_EMPTY.as_slice())
+        } else {
+            U256::from_be_slice(keccak256(code).as_slice())
+        };
+
+        let code_hash_values = split_u256(code_hash);
+        let code_hash_low_key = get_storage_var_address(ACCOUNT_CODE_HASH, &[]);
+        let code_hash_high_key = next_storage_key(&code_hash_low_key)?;
+        storage.append(&mut vec![
+            (code_hash_low_key, Felt::from(code_hash_values[0])),
+            (code_hash_high_key, Felt::from(code_hash_values[1])),
+        ]);
+
         // Initialize the bytecode jumpdests.
         let bytecode = to_analysed(Bytecode::new_raw(code.clone()));
         let valid_jumpdests: Vec<usize> = match bytecode {

crates/ef-testing/src/evm_sequencer/account/v1.rs

@@ -50,6 +50,7 @@ impl KakarotAccount {
         evm_address: &Address,
         code: &Bytes,
         nonce: U256,
+        _balance: U256,
         evm_storage: &[(U256, U256)],
     ) -> Result<Self, StarknetApiError> {
         let nonce = Felt::from(TryInto::<u128>::try_into(nonce).map_err(|err| {

crates/ef-testing/src/evm_sequencer/constants.rs

@@ -119,6 +119,7 @@ pub mod storage_variables {
     pub const ACCOUNT_VALID_JUMPDESTS : &str = "Account_valid_jumpdests";
     pub const ACCOUNT_JUMPDESTS_INITIALIZED : &str = "Account_jumpdests_initialized";
     pub const ACCOUNT_PUBLIC_KEY: &str = "Account_public_key";
+    pub const ACCOUNT_CODE_HASH: &str = "Account_code_hash";
 
     pub const KAKAROT_COINBASE: &str = "Kakarot_coinbase";
     pub const KAKAROT_BASE_FEE: &str = "Kakarot_base_fee";

crates/ef-testing/src/evm_sequencer/evm_state/v0.rs

@@ -345,10 +345,12 @@ mod tests {
             &TEST_CONTRACT_ADDRESS,
             &contract_bytecode,
             contract_nonce,
+            U256::ZERO,
             &[],
         )
         .unwrap();
-        let eoa = KakarotAccount::new(&PUBLIC_KEY, &Bytes::default(), eoa_nonce, &[]).unwrap();
+        let eoa = KakarotAccount::new(&PUBLIC_KEY, &Bytes::default(), eoa_nonce, U256::ZERO, &[])
+            .unwrap();
         sequencer.setup_account(contract).unwrap();
         sequencer.setup_account(eoa).unwrap();
         let execution_result = sequencer.execute_transaction(transaction);

crates/ef-testing/src/evm_sequencer/evm_state/v1.rs

@@ -388,8 +388,14 @@ mod tests {
         ]);
 
         // When
-        let account =
-            KakarotAccount::new(&TEST_CONTRACT_ADDRESS, &bytecode, U256::ZERO, &[]).unwrap();
+        let account = KakarotAccount::new(
+            &TEST_CONTRACT_ADDRESS,
+            &bytecode,
+            U256::ZERO,
+            U256::ZERO,
+            &[],
+        )
+        .unwrap();
         sequencer.setup_account(account).unwrap();
 
         // Then
@@ -438,10 +444,12 @@ mod tests {
             &TEST_CONTRACT_ADDRESS,
             &contract_bytecode,
             contract_nonce,
+            U256::ZERO,
             &[],
         )
         .unwrap();
-        let eoa = KakarotAccount::new(&PUBLIC_KEY, &Bytes::default(), eoa_nonce, &[]).unwrap();
+        let eoa = KakarotAccount::new(&PUBLIC_KEY, &Bytes::default(), eoa_nonce, U256::ZERO, &[])
+            .unwrap();
         sequencer.setup_account(contract).unwrap();
         sequencer.setup_account(eoa).unwrap();
         let execution_result = sequencer.execute_transaction(transaction);

crates/ef-testing/src/models/case.rs

@@ -61,6 +61,7 @@ impl BlockchainTestCase {
                 address,
                 &account.code,
                 account.nonce,
+                account.balance,
                 &account.storage.clone().into_iter().collect::<Vec<_>>()[..],
             )?;
             sequencer.setup_account(kakarot_account)?;