starknet_api: make contract address derivation hash-pluggable

crates/apollo_integration_tests/tests/test_custom_cairo0_txs.rs

@@ -13,7 +13,7 @@ use mempool_test_utils::starknet_api_test_utils::{
     AccountTransactionGenerator,
     MultiAccountTransactionGenerator,
 };
-use starknet_api::core::calculate_contract_address;
+use starknet_api::core::{calculate_contract_address, AddressDerivationHash};
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::test_utils::invoke::rpc_invoke_tx;
@@ -130,6 +130,7 @@ fn generate_invoke_txs_tests_for_deploy_contract(
         test_contract.get_class_hash(),
         &calldata!(constructor_calldata_arg1, constructor_calldata_arg2),
         account_tx_generator.sender_address(),
+        AddressDerivationHash::Pedersen,
     )
     .expect("Failed to calculate contract address");
 

crates/apollo_integration_tests/tests/test_custom_cairo1_txs.rs

@@ -16,7 +16,7 @@ use mempool_test_utils::starknet_api_test_utils::{
 };
 use mempool_test_utils::EMPTY_CONTRACT_CAIRO1_COMPILED_CLASS_HASH;
 use starknet_api::abi::abi_utils::selector_from_name;
-use starknet_api::core::{calculate_contract_address, CompiledClassHash};
+use starknet_api::core::{calculate_contract_address, AddressDerivationHash, CompiledClassHash};
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::test_utils::invoke::rpc_invoke_tx;
 use starknet_api::test_utils::resource_bounds_for_testing;
@@ -178,6 +178,7 @@ fn generate_test_deploy_txs(
         // Constructor calldata of the deployed contract (test_contract).
         &calldata!(constructor_calldata_arg1, constructor_calldata_arg2),
         test_contract.get_instance_address(0), // deployer address
+        AddressDerivationHash::Pedersen,
     )
     .expect("Failed to calculate contract address");
 

crates/apollo_transaction_converter/src/transaction_converter.rs

@@ -8,7 +8,7 @@ use async_trait::async_trait;
 use mockall::automock;
 use starknet_api::consensus_transaction::{ConsensusTransaction, InternalConsensusTransaction};
 use starknet_api::contract_class::{ClassInfo, ContractClass, SierraVersion};
-use starknet_api::core::{ChainId, ClassHash};
+use starknet_api::core::{AddressDerivationHash, ChainId, ClassHash};
 use starknet_api::executable_transaction::{
     AccountTransaction,
     Transaction as ExecutableTransaction,
@@ -395,7 +395,8 @@ impl TransactionConverter {
                 )
             }
             RpcTransaction::DeployAccount(RpcDeployAccountTransaction::V3(tx)) => {
-                let contract_address = tx.calculate_contract_address()?;
+                let contract_address =
+                    tx.calculate_contract_address(AddressDerivationHash::Pedersen)?;
                 (
                     InternalRpcTransactionWithoutTxHash::DeployAccount(
                         InternalRpcDeployAccountTransaction {

crates/blockifier/src/execution/contract_address_test.rs

@@ -2,7 +2,12 @@ use blockifier_test_utils::cairo_versions::CairoVersion;
 use blockifier_test_utils::contracts::FeatureContract;
 use rstest::rstest;
 use starknet_api::abi::abi_utils::selector_from_name;
-use starknet_api::core::{calculate_contract_address, ClassHash, ContractAddress};
+use starknet_api::core::{
+    calculate_contract_address,
+    AddressDerivationHash,
+    ClassHash,
+    ContractAddress,
+};
 use starknet_api::transaction::fields::{Calldata, ContractAddressSalt};
 use starknet_api::{calldata, felt};
 
@@ -38,9 +43,14 @@ fn test_calculate_contract_address() {
             initial_gas: versioned_constants.infinite_gas_for_vm_mode(),
             ..Default::default()
         };
-        let contract_address =
-            calculate_contract_address(salt, class_hash, constructor_calldata, deployer_address)
-                .unwrap();
+        let contract_address = calculate_contract_address(
+            salt,
+            class_hash,
+            constructor_calldata,
+            deployer_address,
+            AddressDerivationHash::Pedersen,
+        )
+        .unwrap();
 
         assert_eq!(
             entry_point_call.execute_directly(state).unwrap().execution,

crates/blockifier/src/execution/deprecated_syscalls/deprecated_syscalls_test.rs

@@ -8,7 +8,7 @@ use pretty_assertions::assert_eq;
 use rstest::rstest;
 use starknet_api::abi::abi_utils::selector_from_name;
 use starknet_api::contract_class::compiled_class_hash::HashVersion;
-use starknet_api::core::calculate_contract_address;
+use starknet_api::core::{calculate_contract_address, AddressDerivationHash};
 use starknet_api::state::StorageKey;
 use starknet_api::test_utils::{
     CHAIN_ID_FOR_TESTS,
@@ -489,6 +489,7 @@ fn test_deploy(
         class_hash,
         &Calldata(constructor_calldata.into()),
         test_contract.get_instance_address(0),
+        AddressDerivationHash::Pedersen,
     )
     .unwrap();
     assert_eq!(

crates/blockifier/src/execution/deprecated_syscalls/hint_processor.rs

@@ -20,6 +20,7 @@ use starknet_api::block::{BlockInfo, BlockNumber, BlockTimestamp};
 use starknet_api::contract_class::EntryPointType;
 use starknet_api::core::{
     calculate_contract_address,
+    AddressDerivationHash,
     ClassHash,
     ContractAddress,
     EntryPointSelector,
@@ -617,6 +618,7 @@ impl DeprecatedSyscallExecutor for DeprecatedSyscallHintProcessor<'_> {
             request.class_hash,
             &request.constructor_calldata,
             deployer_address_for_calculation,
+            AddressDerivationHash::Pedersen,
         )?;
 
         // Increment the Deploy syscall's linear cost counter by the number of elements in the

crates/blockifier/src/execution/stack_trace_test.rs

@@ -15,6 +15,7 @@ use starknet_api::abi::abi_utils::selector_from_name;
 use starknet_api::abi::constants::CONSTRUCTOR_ENTRY_POINT_NAME;
 use starknet_api::core::{
     calculate_contract_address,
+    AddressDerivationHash,
     ClassHash,
     ContractAddress,
     EntryPointSelector,
@@ -774,6 +775,7 @@ fn test_contract_ctor_frame_stack_trace(
         faulty_class_hash,
         &calldata![validate_constructor],
         account_address,
+        AddressDerivationHash::Pedersen,
     )
     .unwrap();
     // Invoke the deploy_contract function on the dummy account to deploy the faulty contract.

crates/blockifier/src/execution/syscalls/syscall_base.rs

@@ -8,6 +8,7 @@ use starknet_api::block::{BlockHash, BlockNumber};
 use starknet_api::contract_class::EntryPointType;
 use starknet_api::core::{
     calculate_contract_address,
+    AddressDerivationHash,
     ClassHash,
     ContractAddress,
     EntryPointSelector,
@@ -407,6 +408,7 @@ impl<'state> SyscallHandlerBase<'state> {
             class_hash,
             &constructor_calldata,
             deployer_address_for_calculation,
+            AddressDerivationHash::Pedersen,
         )?;
 
         let ctor_context = ConstructorContext {

crates/blockifier/src/execution/syscalls/syscall_tests/deploy.rs

@@ -8,7 +8,7 @@ use expect_test::expect;
 use pretty_assertions::assert_eq;
 use rstest::rstest;
 use starknet_api::contract_class::SierraVersion;
-use starknet_api::core::calculate_contract_address;
+use starknet_api::core::{calculate_contract_address, AddressDerivationHash};
 use starknet_api::transaction::fields::{Calldata, ContractAddressSalt, Fee};
 use starknet_api::{calldata, felt};
 use test_case::test_case;
@@ -63,6 +63,7 @@ fn no_constructor(runnable_version: RunnableCairo1) {
         class_hash,
         &calldata![],
         deployer_contract.get_instance_address(0),
+        AddressDerivationHash::Pedersen,
     )
     .unwrap();
 
@@ -120,6 +121,7 @@ fn with_constructor(runnable_version: RunnableCairo1) {
         class_hash,
         &Calldata(constructor_calldata.clone().into()),
         deployer_contract.get_instance_address(0),
+        AddressDerivationHash::Pedersen,
     )
     .unwrap();
 

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -26,6 +26,7 @@ use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCom
 use starknet_api::contract_class::ContractClass;
 use starknet_api::core::{
     calculate_contract_address,
+    AddressDerivationHash,
     ClassHash,
     CompiledClassHash,
     ContractAddress,
@@ -1631,6 +1632,7 @@ fn test_deploy_account_constructor_storage_write(
         class_hash,
         &constructor_calldata,
         ContractAddress::default(),
+        AddressDerivationHash::Pedersen,
     )
     .unwrap();
     let read_storage_arg = state.get_storage_at(deployed_contract_address, storage_key).unwrap();

crates/blockifier/src/transaction/transaction_execution.rs

@@ -1,5 +1,5 @@
 use starknet_api::contract_class::ClassInfo;
-use starknet_api::core::{ContractAddress, Nonce};
+use starknet_api::core::{AddressDerivationHash, ContractAddress, Nonce};
 use starknet_api::executable_transaction::{
     AccountTransaction as ApiExecutableTransaction,
     DeclareTransaction,
@@ -102,7 +102,8 @@ impl Transaction {
             StarknetApiTransaction::DeployAccount(deploy_account) => {
                 let contract_address = match deployed_contract_address {
                     Some(address) => address,
-                    None => deploy_account.calculate_contract_address()?,
+                    None => deploy_account
+                        .calculate_contract_address(AddressDerivationHash::Pedersen)?,
                 };
                 ApiExecutableTransaction::DeployAccount(DeployAccountTransaction {
                     tx: deploy_account,

crates/starknet_api/src/core.rs

@@ -322,16 +322,45 @@ impl TryFrom<StarkHash> for ContractAddress {
     }
 }
 
-// TODO(Noa): Add a hash_function as a parameter
+/// The hash function used to derive a contract address.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum AddressDerivationHash {
+    Pedersen,
+    Blake2,
+}
+
 pub fn calculate_contract_address(
     salt: ContractAddressSalt,
     class_hash: ClassHash,
     constructor_calldata: &Calldata,
     deployer_address: ContractAddress,
+    address_derivation_hash: AddressDerivationHash,
+) -> Result<ContractAddress, StarknetApiError> {
+    match address_derivation_hash {
+        AddressDerivationHash::Pedersen => calculate_contract_address_inner::<Pedersen>(
+            salt,
+            class_hash,
+            constructor_calldata,
+            deployer_address,
+        ),
+        AddressDerivationHash::Blake2 => calculate_contract_address_inner::<Blake2Felt252>(
+            salt,
+            class_hash,
+            constructor_calldata,
+            deployer_address,
+        ),
+    }
+}
+
+fn calculate_contract_address_inner<H: CoreStarkHash>(
+    salt: ContractAddressSalt,
+    class_hash: ClassHash,
+    constructor_calldata: &Calldata,
+    deployer_address: ContractAddress,
 ) -> Result<ContractAddress, StarknetApiError> {
-    let constructor_calldata_hash = Pedersen::hash_array(&constructor_calldata.0);
+    let constructor_calldata_hash = H::hash_array(&constructor_calldata.0);
     let contract_address_prefix = format!("0x{}", hex::encode(CONTRACT_ADDRESS_PREFIX));
-    let address = Pedersen::hash_array(&[
+    let address = H::hash_array(&[
         Felt::from_hex(contract_address_prefix.as_str()).map_err(|_| {
             StarknetApiError::OutOfRange { string: contract_address_prefix.clone() }
         })?,

crates/starknet_api/src/core_test.rs

@@ -9,6 +9,7 @@ use crate::core::{
     ascii_as_felt,
     calculate_contract_address,
     felt_to_u128,
+    AddressDerivationHash,
     ChainId,
     ContractAddress,
     EthAddress,
@@ -61,9 +62,14 @@ fn test_calculate_contract_address() {
     let constructor_calldata =
         Calldata(vec![Felt::from(60_u16), Felt::from(70_u16), Felt::MAX].into());
 
-    let actual_address =
-        calculate_contract_address(salt, class_hash, &constructor_calldata, deployer_address)
-            .unwrap();
+    let actual_address = calculate_contract_address(
+        salt,
+        class_hash,
+        &constructor_calldata,
+        deployer_address,
+        AddressDerivationHash::Pedersen,
+    )
+    .unwrap();
 
     let constructor_calldata_hash = Pedersen::hash_array(&constructor_calldata.0);
     let address = Pedersen::hash_array(&[

crates/starknet_api/src/executable_transaction.rs

@@ -12,7 +12,14 @@ use thiserror::Error;
 
 use crate::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
 use crate::contract_class::{ClassInfo, ContractClass};
-use crate::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce};
+use crate::core::{
+    AddressDerivationHash,
+    ChainId,
+    ClassHash,
+    CompiledClassHash,
+    ContractAddress,
+    Nonce,
+};
 use crate::data_availability::DataAvailabilityMode;
 use crate::transaction::fields::{
     AccountDeploymentData,
@@ -324,7 +331,8 @@ impl DeployAccountTransaction {
         deploy_account_tx: crate::transaction::DeployAccountTransaction,
         chain_id: &ChainId,
     ) -> Result<Self, StarknetApiError> {
-        let contract_address = deploy_account_tx.calculate_contract_address()?;
+        let contract_address =
+            deploy_account_tx.calculate_contract_address(AddressDerivationHash::Pedersen)?;
         let tx_hash =
             deploy_account_tx.calculate_transaction_hash(chain_id, &deploy_account_tx.version())?;
         Ok(Self { tx: deploy_account_tx, tx_hash, contract_address })

crates/starknet_api/src/rpc_transaction.rs

@@ -11,7 +11,14 @@ use starknet_core::types::EntryPointsByType as StarknetCoreEntryPointsByType;
 use strum::{EnumDiscriminants, EnumIter, IntoStaticStr, VariantNames};
 
 use crate::contract_class::EntryPointType;
-use crate::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce};
+use crate::core::{
+    AddressDerivationHash,
+    ChainId,
+    ClassHash,
+    CompiledClassHash,
+    ContractAddress,
+    Nonce,
+};
 use crate::data_availability::DataAvailabilityMode;
 use crate::state::{EntryPoint, SierraContractClass};
 use crate::transaction::fields::{
@@ -178,7 +185,7 @@ impl RpcTransaction {
         match self {
             RpcTransaction::Declare(RpcDeclareTransaction::V3(tx)) => Ok(tx.sender_address),
             RpcTransaction::DeployAccount(RpcDeployAccountTransaction::V3(tx)) => {
-                tx.calculate_contract_address()
+                tx.calculate_contract_address(AddressDerivationHash::Pedersen)
             }
             RpcTransaction::Invoke(RpcInvokeTransaction::V3(tx)) => Ok(tx.sender_address),
         }
@@ -542,7 +549,13 @@ impl TransactionHasher for RpcDeployAccountTransactionV3 {
         chain_id: &ChainId,
         transaction_version: &TransactionVersion,
     ) -> Result<TransactionHash, StarknetApiError> {
-        get_deploy_account_transaction_v3_hash(self, chain_id, transaction_version)
+        let contract_address = self.calculate_contract_address(AddressDerivationHash::Pedersen)?;
+        get_deploy_account_transaction_v3_hash(
+            self,
+            chain_id,
+            transaction_version,
+            contract_address,
+        )
     }
 }
 

crates/starknet_api/src/test_utils/deploy_account.rs

@@ -1,7 +1,7 @@
 use starknet_crypto::Felt;
 
 use super::{NonceManager, TestingTxArgs};
-use crate::core::{ClassHash, Nonce};
+use crate::core::{AddressDerivationHash, ClassHash, Nonce};
 use crate::data_availability::DataAvailabilityMode;
 use crate::executable_transaction::{
     AccountTransaction,
@@ -125,7 +125,7 @@ pub fn executable_deploy_account_tx(deploy_tx_args: DeployAccountTxArgs) -> Acco
     let tx_hash = deploy_tx_args.tx_hash;
     let tx_nonce = deploy_tx_args.nonce;
     let tx = deploy_account_tx(deploy_tx_args, tx_nonce);
-    let contract_address = tx.calculate_contract_address().unwrap();
+    let contract_address = tx.calculate_contract_address(AddressDerivationHash::Pedersen).unwrap();
     let deploy_account_tx = ExecutableDeployAccountTransaction { tx, tx_hash, contract_address };
 
     AccountTransaction::DeployAccount(deploy_account_tx)
@@ -176,7 +176,7 @@ pub fn internal_deploy_account_tx(deploy_tx_args: DeployAccountTxArgs) -> Intern
         unreachable!();
     };
 
-    let contract_address = tx.calculate_contract_address().unwrap();
+    let contract_address = tx.calculate_contract_address(AddressDerivationHash::Pedersen).unwrap();
     let tx_without_hash =
         InternalRpcTransactionWithoutTxHash::DeployAccount(InternalRpcDeployAccountTransaction {
             tx: RpcDeployAccountTransaction::V3(tx),