fixing pedersen to poseidon for invoke tx v3 (#148)

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Next release
 
+- fix(hashes): Fix invoke tx hashes for version v3
 - fix: re-add prometheus, doc cli args, log format
 - fix(program): Changed visibility of program serializer + archived
 - fix(classes): remove the classes ordenation to allow fork rebasements

crates/client/sync/src/utils/convert.rs

@@ -22,7 +22,6 @@ use starknet_providers::sequencer::models::state_update::{
     DeclaredContract, DeployedContract, StateDiff as StateDiffProvider, StorageDiff as StorageDiffProvider,
 };
 use starknet_providers::sequencer::models::{self as p, StateUpdate as StateUpdateProvider};
-use starknet_types_core::felt::Felt;
 
 use crate::commitments::calculate_tx_and_event_commitments;
 use crate::l2::L2SyncError;
@@ -42,13 +41,17 @@ pub fn convert_block(block: p::Block, chain_id: StarkFelt) -> Result<DeoxysBlock
     let event_count = events.len() as u128;
 
     let ((transaction_commitment, txs_hashes), event_commitment) =
-        commitments(&transactions, &events, block_number, chain_id);
+        calculate_tx_and_event_commitments(&transactions, &events, chain_id.into(), block_number);
 
     // Provisory conversion while Starknet-api doesn't support the universal `Felt` type
     let transaction_commitment = Felt252Wrapper::from(transaction_commitment).into();
     let event_commitment = Felt252Wrapper::from(event_commitment).into();
     let txs_hashes: Vec<StarkFelt> = txs_hashes.into_iter().map(Felt252Wrapper::from).map(Into::into).collect();
-
+    if block_number == 524439 {
+        for hash in &txs_hashes {
+            println!("\"{}\"", hash);
+        }
+    }
     let protocol_version = starknet_version(&block.starknet_version);
     let l1_gas_price = resource_price(block.l1_gas_price, block.l1_data_gas_price);
     let l1_da_mode = l1_da_mode(block.l1_da_mode);
@@ -421,18 +424,6 @@ fn event(event: &p::Event) -> starknet_api::transaction::Event {
     }
 }
 
-fn commitments(
-    transactions: &[starknet_api::transaction::Transaction],
-    events: &[starknet_api::transaction::Event],
-    block_number: u64,
-    chain_id: StarkFelt,
-) -> ((Felt, Vec<Felt>), Felt) {
-    let ((commitment_tx, txs_hashes), commitment_event) =
-        calculate_tx_and_event_commitments(transactions, events, chain_id.into(), block_number);
-
-    ((commitment_tx, txs_hashes), commitment_event)
-}
-
 fn felt(field_element: starknet_ff::FieldElement) -> starknet_api::hash::StarkFelt {
     starknet_api::hash::StarkFelt::new(field_element.to_bytes_be()).unwrap()
 }

crates/primitives/block/Cargo.toml

@@ -13,6 +13,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 blockifier = { workspace = true }
 lazy_static = { workspace = true }
+log = { workspace = true }
 mp-felt = { workspace = true }
 serde = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true }

crates/primitives/transactions/src/compute_hash.rs

@@ -16,7 +16,7 @@ use starknet_api::transaction::{
 use starknet_core::utils::starknet_keccak;
 
 use starknet_types_core::felt::Felt;
-use starknet_types_core::hash::{Pedersen, StarkHash}; //, Poseidon};
+use starknet_types_core::hash::{Pedersen, Poseidon, StarkHash}; //, Poseidon};
 
 use super::SIMULATE_TX_VERSION_OFFSET;
 use crate::{LEGACY_BLOCK_NUMBER, LEGACY_L1_HANDLER_BLOCK};
@@ -45,31 +45,36 @@ fn convert_calldata(calldata: Calldata) -> Vec<Felt> {
 }
 
 #[inline]
-fn compute_calldata_hash(calldata: Calldata) -> Felt {
+fn compute_calldata_hash_pedersen(calldata: Calldata) -> Felt {
     Pedersen::hash_array(convert_calldata(calldata).as_slice())
 }
 
+#[inline]
+fn compute_calldata_hash_poseidon(calldata: Calldata) -> Felt {
+    Poseidon::hash_array(convert_calldata(calldata).as_slice())
+}
+
 #[inline]
 fn compute_gas_hash(tip: &Tip, resource_bounds: &ResourceBoundsMapping) -> Felt {
     let gas_as_felt = &[
         Felt::from(tip.0),
         prepare_resource_bound_value(resource_bounds, Resource::L1Gas),
         prepare_resource_bound_value(resource_bounds, Resource::L2Gas),
     ];
-    Pedersen::hash_array(gas_as_felt)
+    Poseidon::hash_array(gas_as_felt)
 }
 
 #[inline]
 fn compute_paymaster_hash(paymaster_data: &PaymasterData) -> Felt {
     let paymaster_tmp = paymaster_data.0.iter().map(|f| Felt::from_bytes_be(&f.0)).collect::<Vec<_>>();
-    Pedersen::hash_array(paymaster_tmp.as_slice())
+    Poseidon::hash_array(paymaster_tmp.as_slice())
 }
 
 #[inline]
 fn compute_account_deployment_hash(account_deployment_data: &AccountDeploymentData) -> Felt {
     let account_deployment_data_tmp =
         &account_deployment_data.0.iter().map(|f| Felt::from_bytes_be(&f.0)).collect::<Vec<_>>();
-    Pedersen::hash_array(account_deployment_data_tmp.as_slice())
+    Poseidon::hash_array(account_deployment_data_tmp.as_slice())
 }
 
 // Use a mapping from execution resources to get corresponding fee bounds
@@ -128,7 +133,7 @@ impl ComputeTransactionHash for InvokeTransactionV0 {
         let sender_address = Felt::from_bytes_be(&self.contract_address.0 .0 .0);
         let entrypoint_selector = Felt::from_bytes_be(&self.entry_point_selector.0 .0);
 
-        let calldata_hash = compute_calldata_hash(self.calldata.clone());
+        let calldata_hash = compute_calldata_hash_pedersen(self.calldata.clone());
         let max_fee = Felt::from(self.max_fee.0);
 
         // Check for deprecated environment
@@ -166,7 +171,7 @@ impl ComputeTransactionHash for InvokeTransactionV1 {
         let sender_address = Felt::from_bytes_be(&self.sender_address.0 .0 .0);
         let entrypoint_selector = Felt::ZERO;
 
-        let calldata_hash = compute_calldata_hash(self.calldata.clone());
+        let calldata_hash = compute_calldata_hash_pedersen(self.calldata.clone());
 
         let max_fee = Felt::from(self.max_fee.0);
         let nonce = Felt::from_bytes_be(&self.nonce.0 .0);
@@ -205,14 +210,11 @@ impl ComputeTransactionHash for InvokeTransactionV3 {
         let data_availability_modes =
             prepare_data_availability_modes(self.nonce_data_availability_mode, self.fee_data_availability_mode);
 
-        let data_hash = {
-            let account_deployment_data_hash = compute_account_deployment_hash(&self.account_deployment_data);
-            let calldata_hash = compute_calldata_hash(self.calldata.clone());
-            Pedersen::hash_array(&[account_deployment_data_hash, calldata_hash])
-        };
+        let account_deployment_data_hash = compute_account_deployment_hash(&self.account_deployment_data);
+        let calldata_hash = compute_calldata_hash_poseidon(self.calldata.clone());
 
         TransactionHash(StarkFelt(
-            Pedersen::hash_array(&[
+            Poseidon::hash_array(&[
                 prefix,
                 version,
                 sender_address,
@@ -221,7 +223,8 @@ impl ComputeTransactionHash for InvokeTransactionV3 {
                 chain_id.into(),
                 nonce,
                 data_availability_modes,
-                data_hash,
+                account_deployment_data_hash,
+                calldata_hash,
             ])
             .to_bytes_be(),
         ))
@@ -345,7 +348,7 @@ impl ComputeTransactionHash for DeclareTransactionV3 {
         let account_deployment_data_hash = compute_account_deployment_hash(&self.account_deployment_data);
 
         TransactionHash(StarkFelt(
-            Pedersen::hash_array(&[
+            Poseidon::hash_array(&[
                 prefix,
                 version,
                 sender_address,
@@ -505,10 +508,10 @@ impl ComputeTransactionHash for DeployAccountTransactionV3 {
         let data_availability_modes =
             prepare_data_availability_modes(self.nonce_data_availability_mode, self.fee_data_availability_mode);
 
-        let constructor_calldata_hash = Pedersen::hash_array(constructor_calldata.as_slice());
+        let constructor_calldata_hash = Poseidon::hash_array(constructor_calldata.as_slice());
 
         TransactionHash(StarkFelt(
-            Pedersen::hash_array(&[
+            Poseidon::hash_array(&[
                 prefix,
                 version,
                 contract_address,