Add direct cast from PyFelt into ContractAddress + Deref

crates/native_blockifier/Cargo.toml

@@ -29,6 +29,7 @@ crate-type = ["cdylib"]
 blockifier = { path = "../blockifier", features = ["testing"] }
 cairo-lang-starknet.workspace = true
 cairo-vm.workspace = true
+derive_more.workspace = true
 indexmap.workspace = true
 log.workspace = true
 num-bigint.workspace = true

crates/native_blockifier/src/py_block_executor.rs

@@ -285,13 +285,13 @@ pub fn into_block_context(
         chain_id: starknet_os_config.chain_id,
         block_number: BlockNumber(block_info.block_number),
         block_timestamp: BlockTimestamp(block_info.block_timestamp),
-        sequencer_address: ContractAddress::try_from(block_info.sequencer_address.0)?,
+        sequencer_address: ContractAddress::try_from(block_info.sequencer_address)?,
         fee_token_addresses: FeeTokenAddresses {
             eth_fee_token_address: ContractAddress::try_from(
-                starknet_os_config.deprecated_fee_token_address.0,
+                starknet_os_config.deprecated_fee_token_address,
             )?,
             strk_fee_token_address: ContractAddress::try_from(
-                starknet_os_config.fee_token_address.0,
+                starknet_os_config.fee_token_address,
             )?,
         },
         vm_resource_fee_cost: general_config.cairo_resource_fee_weights.clone(),

crates/native_blockifier/src/py_declare.rs

@@ -32,7 +32,7 @@ impl TryFrom<PyDeclareTransactionV0V1> for DeclareTransactionV0V1 {
             signature: TransactionSignature(from_py_felts(tx.signature)),
             nonce: Nonce(tx.nonce.0),
             class_hash: ClassHash(tx.class_hash.0),
-            sender_address: ContractAddress::try_from(tx.sender_address.0)?,
+            sender_address: ContractAddress::try_from(tx.sender_address)?,
         })
     }
 }
@@ -56,7 +56,7 @@ impl TryFrom<PyDeclareTransactionV2> for DeclareTransactionV2 {
             nonce: Nonce(tx.nonce.0),
             class_hash: ClassHash(tx.class_hash.0),
             compiled_class_hash: CompiledClassHash(tx.compiled_class_hash.0),
-            sender_address: ContractAddress::try_from(tx.sender_address.0)?,
+            sender_address: ContractAddress::try_from(tx.sender_address)?,
         })
     }
 }
@@ -86,7 +86,7 @@ impl TryFrom<PyDeclareTransactionV3> for DeclareTransactionV3 {
             nonce: Nonce(tx.nonce.0),
             class_hash: ClassHash(tx.class_hash.0),
             compiled_class_hash: CompiledClassHash(tx.compiled_class_hash.0),
-            sender_address: ContractAddress::try_from(tx.sender_address.0)?,
+            sender_address: ContractAddress::try_from(tx.sender_address)?,
             nonce_data_availability_mode: DataAvailabilityMode::from(
                 tx.nonce_data_availability_mode,
             ),

crates/native_blockifier/src/py_deploy_account.rs

@@ -92,6 +92,6 @@ pub fn py_deploy_account(py_tx: &PyAny) -> NativeBlockifierResult<DeployAccountT
 
     let tx_hash = TransactionHash(py_attr::<PyFelt>(py_tx, "hash_value")?.0);
     let contract_address =
-        ContractAddress::try_from(py_attr::<PyFelt>(py_tx, "sender_address")?.0)?;
+        ContractAddress::try_from(py_attr::<PyFelt>(py_tx, "sender_address")?)?;
     Ok(DeployAccountTransaction::new(tx, tx_hash, contract_address))
 }

crates/native_blockifier/src/py_invoke_function.rs

@@ -31,7 +31,7 @@ impl TryFrom<PyInvokeTransactionV0> for InvokeTransactionV0 {
         Ok(Self {
             max_fee: Fee(tx.max_fee),
             signature: TransactionSignature(from_py_felts(tx.signature)),
-            contract_address: ContractAddress::try_from(tx.sender_address.0)?,
+            contract_address: ContractAddress::try_from(tx.sender_address)?,
             entry_point_selector: EntryPointSelector(tx.entry_point_selector.0),
             calldata: Calldata(Arc::from(from_py_felts(tx.calldata))),
         })
@@ -54,7 +54,7 @@ impl TryFrom<PyInvokeTransactionV1> for InvokeTransactionV1 {
             max_fee: Fee(tx.max_fee),
             signature: TransactionSignature(from_py_felts(tx.signature)),
             nonce: Nonce(tx.nonce.0),
-            sender_address: ContractAddress::try_from(tx.sender_address.0)?,
+            sender_address: ContractAddress::try_from(tx.sender_address)?,
             calldata: Calldata(Arc::from(from_py_felts(tx.calldata))),
         })
     }
@@ -82,7 +82,7 @@ impl TryFrom<PyInvokeTransactionV3> for InvokeTransactionV3 {
             tip: Tip(tx.tip),
             signature: TransactionSignature(from_py_felts(tx.signature)),
             nonce: Nonce(tx.nonce.0),
-            sender_address: ContractAddress::try_from(tx.sender_address.0)?,
+            sender_address: ContractAddress::try_from(tx.sender_address)?,
             calldata: Calldata(Arc::from(from_py_felts(tx.calldata))),
             nonce_data_availability_mode: DataAvailabilityMode::from(
                 tx.nonce_data_availability_mode,

crates/native_blockifier/src/py_l1_handler.rs

@@ -23,7 +23,7 @@ impl TryFrom<PyL1HandlerTransaction> for starknet_api::transaction::L1HandlerTra
         Ok(Self {
             version: constants::L1_HANDLER_VERSION,
             nonce: Nonce(tx.nonce.0),
-            contract_address: ContractAddress::try_from(tx.contract_address.0)?,
+            contract_address: ContractAddress::try_from(tx.contract_address)?,
             entry_point_selector: EntryPointSelector(tx.entry_point_selector.0),
             calldata: Calldata(Arc::from(from_py_felts(tx.calldata))),
         })

crates/native_blockifier/src/py_state_diff.rs

@@ -30,14 +30,14 @@ impl TryFrom<PyStateDiff> for StateDiff {
     fn try_from(state_diff: PyStateDiff) -> NativeBlockifierResult<Self> {
         let mut deployed_contracts: IndexMap<ContractAddress, ClassHash> = IndexMap::new();
         for (address, class_hash) in state_diff.address_to_class_hash {
-            let address = ContractAddress::try_from(address.0)?;
+            let address = ContractAddress::try_from(address)?;
             let class_hash = ClassHash(class_hash.0);
             deployed_contracts.insert(address, class_hash);
         }
 
         let mut storage_diffs = IndexMap::new();
         for (address, storage_mapping) in state_diff.storage_updates {
-            let address = ContractAddress::try_from(address.0)?;
+            let address = ContractAddress::try_from(address)?;
             storage_diffs.insert(address, IndexMap::new());
 
             for (key, value) in storage_mapping {
@@ -51,7 +51,7 @@ impl TryFrom<PyStateDiff> for StateDiff {
 
         let mut nonces = IndexMap::new();
         for (address, nonce) in state_diff.address_to_nonce {
-            let address = ContractAddress::try_from(address.0)?;
+            let address = ContractAddress::try_from(address)?;
             let nonce = Nonce(nonce.0);
             nonces.insert(address, nonce);
         }

crates/native_blockifier/src/py_utils.rs

@@ -6,10 +6,11 @@ use pyo3::prelude::*;
 use starknet_api::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, EthAddress};
 use starknet_api::hash::StarkFelt;
 use starknet_api::state::StorageKey;
+use starknet_api::StarknetApiError;
 
 use crate::errors::NativeBlockifierResult;
 
-#[derive(Clone, Copy, Debug, Default, Eq, FromPyObject, Hash, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, Eq, FromPyObject, Hash, PartialEq, derive_more::Deref)]
 pub struct PyFelt(#[pyo3(from_py_with = "int_to_stark_felt")] pub StarkFelt);
 
 impl IntoPy<PyObject> for PyFelt {
@@ -64,6 +65,14 @@ impl From<StorageKey> for PyFelt {
     }
 }
 
+impl TryFrom<PyFelt> for ContractAddress {
+    type Error = StarknetApiError;
+
+    fn try_from(value: PyFelt) -> Result<Self, Self::Error> {
+        Self::try_from(value.0)
+    }
+}
+
 fn int_to_stark_felt(int: &PyAny) -> PyResult<StarkFelt> {
     let biguint: BigUint = int.extract()?;
     biguint_to_felt(biguint).map_err(|e| PyValueError::new_err(e.to_string()))

crates/native_blockifier/src/storage.rs

@@ -147,7 +147,7 @@ impl Storage for PapyrusStorage {
         // i.e.: pointing to a non-zeroed class hash). Rest would be (newly) deployed classes.
         let mut replaced_classes = IndexMap::<ContractAddress, ClassHash>::new();
         for (address, class_hash) in &py_state_diff.address_to_class_hash {
-            let address = ContractAddress::try_from(address.0)?;
+            let address = ContractAddress::try_from(*address)?;
             let address_assigned: bool = self
                 .reader()
                 .begin_ro_txn()?