Chore/bump kakarot v0 5 1

src/eth_provider/starknet/kakarot_core.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use crate::{into_via_try_wrapper, models::felt::Felt252Wrapper};
+use crate::models::felt::Felt252Wrapper;
 use alloy_rlp::Encodable;
 use cainome::rs::abigen_legacy;
 use dotenvy::dotenv;
@@ -56,12 +56,12 @@ lazy_static! {
 /// Compute the starknet address given a eth address
 #[inline]
 pub fn starknet_address(address: Address) -> FieldElement {
-    let evm_address = into_via_try_wrapper!(address).unwrap();
+    let evm_address = into_via_wrapper!(address);
     get_contract_address(
-        into_via_wrapper!(address),
+        evm_address,
         *UNINITIALIZED_ACCOUNT_CLASS_HASH,
         &[*KAKAROT_ADDRESS, evm_address],
-        *KAKAROT_ADDRESS,
+        FieldElement::ZERO,
     )
 }
 

src/test_utils/constants.rs

@@ -1,5 +1,4 @@
 pub const ACCOUNT_EVM_ADDRESS: &str = "Account_evm_address";
-pub const ACCOUNT_KAKAROT_ADDRESS: &str = "Account_kakarot_address";
 pub const ACCOUNT_IMPLEMENTATION: &str = "Account_implementation";
 pub const ACCOUNT_NONCE: &str = "Account_nonce";
 pub const ACCOUNT_STORAGE: &str = "Account_storage";

src/test_utils/hive/mod.rs

@@ -13,9 +13,7 @@ use starknet_api::core::ClassHash;
 use starknet_crypto::FieldElement;
 
 use super::{
-    constants::{
-        ACCOUNT_IMPLEMENTATION, ACCOUNT_KAKAROT_ADDRESS, ACCOUNT_NONCE, KAKAROT_EVM_TO_STARKNET_ADDRESS, OWNABLE_OWNER,
-    },
+    constants::{ACCOUNT_IMPLEMENTATION, ACCOUNT_NONCE, KAKAROT_EVM_TO_STARKNET_ADDRESS, OWNABLE_OWNER},
     katana::genesis::{KatanaGenesisBuilder, Loaded},
 };
 
@@ -88,14 +86,13 @@ impl HiveGenesisConfig {
                 let mut kakarot_account_storage: Vec<(FieldElement, FieldElement)> =
                     kakarot_account.storage().iter().map(|(k, v)| ((*k.0.key()).into(), (*v).into())).collect();
 
-                // Add the implementation and the kakarot address to the storage.
+                // Add the implementation to the storage.
                 let implementation_key = get_storage_var_address(ACCOUNT_IMPLEMENTATION, &[])?;
                 kakarot_account_storage.append(&mut vec![
                     (implementation_key, account_contract_class_hash.0.into()),
                     (get_storage_var_address(ACCOUNT_NONCE, &[])?, FieldElement::ONE),
                     (get_storage_var_address(OWNABLE_OWNER, &[])?, kakarot_address),
                 ]);
-                kakarot_account_storage.push((get_storage_var_address(ACCOUNT_KAKAROT_ADDRESS, &[])?, kakarot_address));
 
                 let key = get_storage_var_address("ERC20_allowances", &[starknet_address, kakarot_address])?;
                 fee_token_storage.insert(key, FieldElement::from(u128::MAX));

src/test_utils/katana/genesis.rs

@@ -3,8 +3,6 @@ use std::fs;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
-use cairo_lang_starknet::casm_contract_class::CasmContractClass;
-use cairo_lang_starknet::contract_class::ContractClass;
 use ethers::signers::LocalWallet;
 use ethers::signers::Signer;
 use ethers::types::U256;
@@ -28,15 +26,15 @@ use serde_json::Value;
 use serde_with::serde_as;
 use starknet::core::serde::unsigned_field_element::UfeHex;
 use starknet::core::types::contract::legacy::LegacyContractClass;
+use starknet::core::types::contract::SierraClass;
 use starknet::core::types::FieldElement;
 use starknet::core::utils::{get_contract_address, get_storage_var_address, get_udc_deployed_address, UdcUniqueness};
 use walkdir::WalkDir;
 
 use crate::test_utils::constants::{
-    ACCOUNT_EVM_ADDRESS, ACCOUNT_IMPLEMENTATION, ACCOUNT_KAKAROT_ADDRESS, KAKAROT_ACCOUNT_CONTRACT_CLASS_HASH,
-    KAKAROT_BASE_FEE, KAKAROT_BLOCK_GAS_LIMIT, KAKAROT_COINBASE, KAKAROT_EVM_TO_STARKNET_ADDRESS,
-    KAKAROT_NATIVE_TOKEN_ADDRESS, KAKAROT_PRECOMPILES_CLASS_HASH, KAKAROT_PREV_RANDAO,
-    KAKAROT_UNINITIALIZED_ACCOUNT_CLASS_HASH, OWNABLE_OWNER,
+    ACCOUNT_EVM_ADDRESS, ACCOUNT_IMPLEMENTATION, KAKAROT_ACCOUNT_CONTRACT_CLASS_HASH, KAKAROT_BASE_FEE,
+    KAKAROT_BLOCK_GAS_LIMIT, KAKAROT_COINBASE, KAKAROT_EVM_TO_STARKNET_ADDRESS, KAKAROT_NATIVE_TOKEN_ADDRESS,
+    KAKAROT_PRECOMPILES_CLASS_HASH, KAKAROT_PREV_RANDAO, KAKAROT_UNINITIALIZED_ACCOUNT_CLASS_HASH, OWNABLE_OWNER,
 };
 
 lazy_static! {
@@ -219,6 +217,7 @@ impl KatanaGenesisBuilder<Loaded> {
                 account_contract_class_hash,
                 uninitialized_account_class_hash,
                 precompiles_class_hash,
+                coinbase_address,
                 block_gas_limit,
             ],
         ));
@@ -264,7 +263,6 @@ impl KatanaGenesisBuilder<Initialized> {
         // Set the eoa storage
         let eoa_storage = [
             (storage_addr(ACCOUNT_EVM_ADDRESS)?, evm_address),
-            (storage_addr(ACCOUNT_KAKAROT_ADDRESS)?, kakarot_address),
             (storage_addr(OWNABLE_OWNER)?, kakarot_address),
             (storage_addr(ACCOUNT_IMPLEMENTATION)?, account_contract_class_hash),
         ]
@@ -359,7 +357,7 @@ impl KatanaGenesisBuilder<Initialized> {
             evm_address,
             uninitialized_account_class_hash,
             &[kakarot_address, evm_address],
-            kakarot_address,
+            FieldElement::ZERO,
         )))
     }
 
@@ -383,11 +381,8 @@ impl KatanaGenesisBuilder<Initialized> {
 }
 
 fn compute_class_hash(class: &Value) -> Result<FieldElement> {
-    match serde_json::from_value::<ContractClass>(class.clone()) {
-        Ok(casm) => {
-            let casm = CasmContractClass::from_contract_class(casm, true).expect("Failed to convert class");
-            Ok(FieldElement::from_bytes_be(&casm.compiled_class_hash().to_be_bytes())?)
-        }
+    match serde_json::from_value::<SierraClass>(class.clone()) {
+        Ok(sierra) => Ok(sierra.class_hash()?),
         Err(_) => {
             let casm: LegacyContractClass =
                 serde_json::from_value(class.clone()).expect("Failed to parse class code v0");