added pallet test for InvokeTransaction::V0

CHANGELOG.md

@@ -63,6 +63,7 @@
 - feat: Remove generic hasher from block hash computation
 - refacto: git submodules removed
 - test: Add pallet test for transaction declare V0
+- test: Add pallet test for transaction invoke V0
 
 ## v0.7.0
 

crates/pallets/starknet/src/tests/invoke_tx.rs

@@ -11,13 +11,14 @@ use sp_runtime::traits::ValidateUnsigned;
 use sp_runtime::transaction_validity::{
     InvalidTransaction, TransactionSource, TransactionValidityError, ValidTransaction,
 };
+use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, EntryPointSelector, Nonce, PatriciaKey};
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce, PatriciaKey};
 use starknet_api::data_availability::DataAvailabilityMode;
 use starknet_api::hash::StarkFelt;
 use starknet_api::state::StorageKey;
 use starknet_api::transaction::{
-    Calldata, ContractAddressSalt, Event as StarknetEvent, EventContent, EventData, EventKey, Fee, TransactionHash,
-    TransactionSignature,
+    Calldata, ContractAddressSalt, Event as StarknetEvent, EventContent, EventData, EventKey, Fee,
+    InvokeTransaction as StarknetInvokeTransaction, InvokeTransactionV0, TransactionHash, TransactionSignature,
 };
 use starknet_core::utils::{get_selector_from_name, get_udc_deployed_address, UdcUniqueSettings, UdcUniqueness};
 use starknet_crypto::FieldElement;
@@ -66,7 +67,7 @@ fn given_hardcoded_contract_run_invoke_tx_fails_sender_not_deployed() {
 #[test]
 fn given_hardcoded_contract_run_invoke_tx_then_it_works() {
     new_test_ext::<MockRuntime>().execute_with(|| {
-        basic_test_setup(2);
+        basic_test_setup(1);
 
         let transaction = get_invoke_dummy(Starknet::chain_id(), NONCE_ZERO);
 
@@ -102,6 +103,76 @@ fn given_hardcoded_contract_run_invoke_tx_then_it_works() {
     });
 }
 
+#[test]
+fn given_hardcoded_contract_run_invoke_tx_v0_then_it_works() {
+    new_test_ext::<MockRuntime>().execute_with(|| {
+        basic_test_setup(1);
+
+        let transaction = create_invoke_dummy_v0_transaction(
+            Starknet::chain_id().into(),
+            AccountType::V0(AccountTypeV0Inner::NoValidate),
+            Some(NONCE_ZERO),
+            None,
+        );
+
+        assert_ok!(Starknet::invoke(RuntimeOrigin::none(), transaction));
+
+        let pending_txs = Starknet::pending();
+        pretty_assertions::assert_eq!(pending_txs.len(), 1);
+        let pending_hashes = Starknet::pending_hashes();
+        pretty_assertions::assert_eq!(pending_hashes.len(), 1);
+        let tx_hash = TransactionHash(
+            StarkFelt::try_from("0x02dfd0ded452658d67535279591c1ed9898431e1eafad7896239f0bfa68493d6").unwrap(),
+        );
+
+        assert_eq!(pending_hashes[0], tx_hash);
+        let events: Vec<StarknetEvent> = Starknet::tx_events(tx_hash);
+        println!("events: {events:?}");
+
+        assert!(events.into_iter().any(|e| e
+            == StarknetEvent {
+                from_address: Starknet::fee_token_addresses().eth_fee_token_address,
+                content: EventContent {
+                    keys: vec![EventKey(
+                        Felt252Wrapper::from(get_selector_from_name(TRANSFER_SELECTOR_NAME).unwrap()).into()
+                    )],
+                    data: EventData(vec![
+                        StarkFelt::try_from(BLOCKIFIER_ACCOUNT_ADDRESS).unwrap(),
+                        StarkFelt::try_from("0xdead").unwrap(),
+                        StarkFelt::try_from("0x2f8").unwrap(),
+                        StarkFelt::from(0u128),
+                    ]),
+                },
+            }));
+    });
+}
+
+pub fn create_invoke_dummy_v0_transaction(
+    chain_id: Felt252Wrapper,
+    account_type: AccountType,
+    nonce: Option<Nonce>,
+    calldata: Option<Vec<StarkFelt>>,
+) -> StarknetInvokeTransaction {
+    let contract_address = ContractAddress(PatriciaKey(
+        StarkFelt::try_from("0x03e437FB56Bb213f5708Fcd6966502070e276c093ec271aA33433b89E21fd31f").unwrap(),
+    ));
+
+    let calldata = Calldata(Arc::new(calldata.unwrap_or_default()));
+
+    let max_fee = Fee(0);
+    let signature = TransactionSignature::default();
+    let entry_point_selector = EntryPointSelector::default();
+    let nonce = nonce.unwrap_or(Nonce::default());
+
+    StarknetInvokeTransaction::V0(InvokeTransactionV0 {
+        max_fee,
+        signature,
+        contract_address,
+        entry_point_selector,
+        calldata,
+    })
+}
+
 #[test]
 fn given_hardcoded_contract_run_invoke_tx_then_event_is_emitted() {
     new_test_ext::<MockRuntime>().execute_with(|| {
@@ -133,20 +204,18 @@ fn given_hardcoded_contract_run_invoke_tx_then_event_is_emitted() {
                 )],
                 data: EventData(vec![
                     StarkFelt::try_from("0x01a3339ec92ac1061e3e0f8e704106286c642eaf302e94a582e5f95ef5e6b4d0").unwrap(), // From
-                    StarkFelt::try_from("0xdead").unwrap(), // To
-                    StarkFelt::try_from("0x2f8").unwrap(),  // Amount low
-                    StarkFelt::from(0u128),                 // Amount high
+                    StarkFelt::try_from("0xdead").unwrap(),
+                    StarkFelt::try_from("0x2f8").unwrap(),
+                    StarkFelt::from(0u128),
                 ]),
             },
         };
         let events: Vec<StarknetEvent> = Starknet::tx_events(tx_hash);
 
-        // Actual event.
         pretty_assertions::assert_eq!(
             emitted_event.clone(),
             events[events.len() - 2]
         );
-        // Fee transfer event.
         pretty_assertions::assert_eq!(
             expected_fee_transfer_event.clone(),
             events.last().unwrap().clone()