Update 'simple_storage_with_event' contract to cairo 1

starknet_py/tests/e2e/client/full_node_test.py

@@ -35,9 +35,9 @@ def _parse_event_name(event: str) -> str:
 
 
 FUNCTION_ONE_NAME = "put"
-EVENT_ONE_PARSED_NAME = _parse_event_name("put_called")
+EVENT_ONE_PARSED_NAME = _parse_event_name("PutCalled")
 FUNCTION_TWO_NAME = "another_put"
-EVENT_TWO_PARSED_NAME = _parse_event_name("another_put_called")
+EVENT_TWO_PARSED_NAME = _parse_event_name("AnotherPutCalled")
 
 
 @pytest.mark.run_on_devnet
@@ -147,7 +147,7 @@ async def test_get_events_without_following_continuation_token(
     simple_storage_with_event_contract: Contract,
 ):
     for i in range(4):
-        await simple_storage_with_event_contract.functions[FUNCTION_ONE_NAME].invoke_v1(
+        await simple_storage_with_event_contract.functions[FUNCTION_ONE_NAME].invoke_v3(
             i, i, auto_estimate=True
         )
 

starknet_py/tests/e2e/fixtures/contracts.py

@@ -4,11 +4,7 @@
 import pytest
 import pytest_asyncio
 
-from starknet_py.common import (
-    create_casm_class,
-    create_compiled_contract,
-    create_sierra_compiled_contract,
-)
+from starknet_py.common import create_casm_class, create_sierra_compiled_contract
 from starknet_py.constants import FEE_CONTRACT_ADDRESS
 from starknet_py.contract import Contract
 from starknet_py.hash.casm_class_hash import compute_casm_class_hash
@@ -127,21 +123,6 @@ async def deployed_balance_contract(
     return deploy_result.deployed_contract
 
 
-@pytest_asyncio.fixture(scope="function")
-async def simple_storage_with_event_contract(
-    account: BaseAccount,
-    simple_storage_with_event_compiled_contract: str,
-    simple_storage_with_event_class_hash: int,
-) -> Contract:
-    """
-    Deploys storage contract with an events and returns its instance.
-    """
-    abi = create_compiled_contract(
-        compiled_contract=simple_storage_with_event_compiled_contract
-    ).abi
-    return await deploy_contract(account, simple_storage_with_event_class_hash, abi)
-
-
 @pytest.fixture(scope="package")
 def eth_fee_contract(account: BaseAccount, fee_contract_abi) -> Contract:
     """
@@ -260,19 +241,3 @@ async def argent_cairo1_account_class_hash(
         compiled_account_contract=compiled_contract,
         compiled_account_contract_casm=compiled_contract_casm,
     )
-
-
-@pytest_asyncio.fixture(scope="package")
-async def simple_storage_with_event_class_hash(
-    account: BaseAccount, simple_storage_with_event_compiled_contract: str
-):
-    """
-    Returns class_hash of the simple_storage_with_event.cairo
-    """
-    declare = await account.sign_declare_v1(
-        compiled_contract=simple_storage_with_event_compiled_contract,
-        max_fee=int(1e16),
-    )
-    res = await account.client.declare(declare)
-    await account.client.wait_for_tx(res.transaction_hash)
-    return res.class_hash

starknet_py/tests/e2e/fixtures/contracts_v1.py

@@ -240,3 +240,24 @@ def map_compiled_contract_and_class_hash() -> Tuple[str, int]:
         contract["sierra"],
         compute_casm_class_hash(create_casm_class(contract["casm"])),
     )
+
+
+@pytest_asyncio.fixture(scope="package")
+async def simple_storage_with_event_class_hash(account: BaseAccount) -> int:
+    contract = load_contract("SimpleStorageWithEvent")
+    class_hash, _ = await declare_cairo1_contract(
+        account, contract["sierra"], contract["casm"]
+    )
+    return class_hash
+
+
+@pytest_asyncio.fixture(scope="function")
+async def simple_storage_with_event_contract(
+    account: BaseAccount,
+    simple_storage_with_event_class_hash: int,
+) -> Contract:
+    return await deploy_v1_contract(
+        account=account,
+        contract_name="SimpleStorageWithEvent",
+        class_hash=simple_storage_with_event_class_hash,
+    )

starknet_py/tests/e2e/mock/contracts_v1/src/lib.cairo

@@ -9,3 +9,4 @@ mod test_enum;
 mod test_option;
 mod token_bridge;
 mod map;
+mod simple_storage_with_event;

starknet_py/tests/e2e/mock/contracts_v1/src/simple_storage_with_event.cairo

@@ -0,0 +1,39 @@
+
+
+#[contract]
+mod SimpleStorageWithEvent {
+
+    struct Storage {
+        map: LegacyMap::<felt252, felt252>,
+    }
+
+    #[event]
+    fn PutCalled (
+        key: felt252,
+        prev_value: felt252,
+        value: felt252,
+    ){}
+
+    #[event]
+    fn AnotherPutCalled(
+        key: felt252,
+        prev_value: felt252,
+        value: felt252,
+        additional_value: felt252,
+    ){}
+
+    #[external]
+    fn put(key: felt252, value: felt252) {
+        let mut prev_value = map::read(key);
+        map::write(key, value);
+        PutCalled(key, prev_value, value);
+    }
+
+    #[external]
+    fn another_put(key: felt252, value: felt252) {
+        let mut prev_value = map::read(key);
+        map::write(key, value);
+        AnotherPutCalled(key, prev_value, value, value);
+    }
+
+}

starknet_py/tests/e2e/mock/contracts_v2/src/lib.cairo

@@ -11,3 +11,4 @@ mod test_enum;
 mod test_option;
 mod token_bridge;
 mod map;
+mod simple_storage_with_event;

starknet_py/tests/e2e/mock/contracts_v2/src/simple_storage_with_event.cairo

@@ -0,0 +1,52 @@
+#[starknet::interface]
+trait ISimpleStorageWithEvent<TContractState> {
+    fn put(ref self: TContractState, key: felt252, value: felt252);
+    fn another_put(ref self: TContractState, key: felt252, value: felt252);
+}
+
+#[derive(Drop, Clone, starknet::Event)]
+struct PutCalled {
+    key: felt252,
+    prev_value: felt252,
+    value: felt252,
+}
+
+#[derive(Drop, Clone, starknet::Event)]
+struct AnotherPutCalled {
+    key: felt252,
+    prev_value: felt252,
+    value: felt252,
+    additional_value: felt252,
+}
+
+#[starknet::contract]
+pub mod SimpleStorageWithEvent {
+    use super::{PutCalled, AnotherPutCalled};
+
+    #[storage]
+    struct Storage {
+        map: LegacyMap::<felt252, felt252>,
+    }
+
+    #[event]
+    #[derive(Drop, Clone, starknet::Event)]
+    pub enum Event {
+        PutCalled: PutCalled,
+        AnotherPutCalled: AnotherPutCalled,
+    }
+
+    #[abi(embed_v0)]
+    impl SimpleStorag of super::ISimpleStorageWithEvent<ContractState> {
+        fn put(ref self: ContractState, key: felt252, value: felt252) {
+            let mut prev_value = self.map.read(key);
+            self.map.write(key, value);
+            self.emit(PutCalled { key: key, prev_value: prev_value, value: value });
+        }
+
+        fn another_put(ref self: ContractState, key: felt252, value: felt252) {
+            let mut prev_value = self.map.read(key);
+            self.map.write(key, value);
+            self.emit(AnotherPutCalled { key: key, prev_value: prev_value, value: value, additional_value: value });
+        }
+    }
+}