Check indexed keys

Scarb.lock

@@ -28,6 +28,7 @@ dependencies = [
  "openzeppelin_introspection",
  "openzeppelin_test_common",
  "openzeppelin_testing",
+ "openzeppelin_utils",
  "snforge_std",
 ]
 
@@ -110,6 +111,7 @@ version = "3.0.0-alpha.0"
 dependencies = [
  "openzeppelin_test_common",
  "openzeppelin_testing",
+ "openzeppelin_utils",
  "snforge_std",
 ]
 

Scarb.toml

@@ -26,8 +26,8 @@ edition.workspace = true
 [workspace.package]
 version = "3.0.0-alpha.0"
 edition = "2024_07"
-cairo-version = "2.11.4"
-scarb-version = "2.11.4"
+cairo-version = "2.12.0-rc.2"
+scarb-version = "2.12.0-rc.2"
 authors = ["OpenZeppelin Community <maintainers@openzeppelin.org>"]
 description = "OpenZeppelin Contracts written in Cairo for Starknet, a decentralized ZK Rollup"
 documentation = "https://docs.openzeppelin.com/contracts-cairo"
@@ -42,8 +42,8 @@ keywords = [
 ]
 
 [workspace.dependencies]
-assert_macros = "2.11.4"
-starknet = "2.11.4"
+assert_macros = "2.12.0-rc.2"
+starknet = "2.12.0-rc.2"
 snforge_std = "0.46.0"
 
 [dependencies]

packages/access/Scarb.toml

@@ -31,6 +31,7 @@ assert_macros.workspace = true
 snforge_std.workspace = true
 openzeppelin_testing = { path = "../testing" }
 openzeppelin_test_common = { path = "../test_common" }
+openzeppelin_utils = { path = "../utils" }
 
 [lib]
 

packages/access/src/tests/test_accesscontrol.cairo

@@ -4,11 +4,12 @@ use openzeppelin_testing::constants::{
     ADMIN, AUTHORIZED, OTHER, OTHER_ADMIN, OTHER_ROLE, ROLE, TIMESTAMP, ZERO,
 };
 use openzeppelin_testing::{EventSpyExt, EventSpyQueue as EventSpy, spy_events};
-use snforge_std::{start_cheat_block_timestamp_global, start_cheat_caller_address, test_address};
-use starknet::ContractAddress;
-use crate::accesscontrol::AccessControlComponent::{
-    InternalImpl, RoleAdminChanged, RoleGranted, RoleGrantedWithDelay, RoleRevoked,
+use openzeppelin_utils::serde::SerializedAppend;
+use snforge_std::{
+    Event, start_cheat_block_timestamp_global, start_cheat_caller_address, test_address,
 };
+use starknet::ContractAddress;
+use crate::accesscontrol::AccessControlComponent::InternalImpl;
 use crate::accesscontrol::interface::{
     IACCESSCONTROL_ID, IAccessControl, IAccessControlCamel, IAccessControlWithDelay, RoleStatus,
 };
@@ -700,9 +701,15 @@ pub impl AccessControlSpyHelpersImpl of AccessControlSpyHelpers {
         account: ContractAddress,
         sender: ContractAddress,
     ) {
-        let expected = AccessControlComponent::Event::RoleRevoked(
-            RoleRevoked { role, account, sender },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("RoleRevoked"));
+
+        let mut data = array![];
+        data.append_serde(role);
+        data.append_serde(account);
+        data.append_serde(sender);
+
+        let expected = Event { keys, data };
         self.assert_emitted_single(contract, expected);
     }
 
@@ -713,9 +720,15 @@ pub impl AccessControlSpyHelpersImpl of AccessControlSpyHelpers {
         account: ContractAddress,
         sender: ContractAddress,
     ) {
-        let expected = AccessControlComponent::Event::RoleRevoked(
-            RoleRevoked { role, account, sender },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("RoleRevoked"));
+
+        let mut data = array![];
+        data.append_serde(role);
+        data.append_serde(account);
+        data.append_serde(sender);
+
+        let expected = Event { keys, data };
         self.assert_only_event(contract, expected);
     }
 
@@ -726,9 +739,15 @@ pub impl AccessControlSpyHelpersImpl of AccessControlSpyHelpers {
         account: ContractAddress,
         sender: ContractAddress,
     ) {
-        let expected = AccessControlComponent::Event::RoleGranted(
-            RoleGranted { role, account, sender },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("RoleGranted"));
+
+        let mut data = array![];
+        data.append_serde(role);
+        data.append_serde(account);
+        data.append_serde(sender);
+
+        let expected = Event { keys, data };
         self.assert_only_event(contract, expected);
     }
 
@@ -740,9 +759,16 @@ pub impl AccessControlSpyHelpersImpl of AccessControlSpyHelpers {
         sender: ContractAddress,
         delay: u64,
     ) {
-        let expected = AccessControlComponent::Event::RoleGrantedWithDelay(
-            RoleGrantedWithDelay { role, account, sender, delay },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("RoleGrantedWithDelay"));
+
+        let mut data = array![];
+        data.append_serde(role);
+        data.append_serde(account);
+        data.append_serde(sender);
+        data.append_serde(delay);
+
+        let expected = Event { keys, data };
         self.assert_only_event(contract, expected);
     }
 
@@ -753,9 +779,15 @@ pub impl AccessControlSpyHelpersImpl of AccessControlSpyHelpers {
         previous_admin_role: felt252,
         new_admin_role: felt252,
     ) {
-        let expected = AccessControlComponent::Event::RoleAdminChanged(
-            RoleAdminChanged { role, previous_admin_role, new_admin_role },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("RoleAdminChanged"));
+
+        let mut data = array![];
+        data.append_serde(role);
+        data.append_serde(previous_admin_role);
+        data.append_serde(new_admin_role);
+
+        let expected = Event { keys, data };
         self.assert_only_event(from_address, expected);
     }
 }

packages/access/src/tests/test_accesscontrol_default_admin_rules.cairo

@@ -5,12 +5,12 @@ use openzeppelin_testing::constants::{
     ADMIN, AUTHORIZED, OTHER, OTHER_ADMIN, OTHER_ROLE, ROLE, TIMESTAMP, ZERO,
 };
 use openzeppelin_testing::{EventSpyExt, EventSpyQueue as EventSpy, spy_events};
-use snforge_std::{start_cheat_block_timestamp_global, start_cheat_caller_address, test_address};
-use starknet::ContractAddress;
-use crate::accesscontrol::extensions::AccessControlDefaultAdminRulesComponent::{
-    DefaultAdminDelayChangeCanceled, DefaultAdminDelayChangeScheduled, DefaultAdminTransferCanceled,
-    DefaultAdminTransferScheduled, InternalTrait,
+use openzeppelin_utils::serde::SerializedAppend;
+use snforge_std::{
+    Event, start_cheat_block_timestamp_global, start_cheat_caller_address, test_address,
 };
+use starknet::ContractAddress;
+use crate::accesscontrol::extensions::AccessControlDefaultAdminRulesComponent::InternalTrait;
 use crate::accesscontrol::extensions::interface::{
     IACCESSCONTROL_DEFAULT_ADMIN_RULES_ID, IAccessControlDefaultAdminRules,
 };
@@ -1169,39 +1169,48 @@ impl AccessControlDefaultAdminRulesSpyHelpersImpl of AccessControlDefaultAdminRu
         new_admin: ContractAddress,
         accept_schedule: u64,
     ) {
-        let expected =
-            AccessControlDefaultAdminRulesComponent::Event::DefaultAdminTransferScheduled(
-            DefaultAdminTransferScheduled { new_admin, accept_schedule },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("DefaultAdminTransferScheduled"));
+        keys.append_serde(new_admin);
+
+        let mut data = array![];
+        data.append_serde(accept_schedule);
+
+        let expected = Event { keys, data };
         self.assert_only_event(contract, expected);
     }
 
     fn assert_only_event_default_admin_transfer_canceled(
         ref self: EventSpy, contract: ContractAddress,
     ) {
-        let expected = AccessControlDefaultAdminRulesComponent::Event::DefaultAdminTransferCanceled(
-            DefaultAdminTransferCanceled {},
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("DefaultAdminTransferCanceled"));
+
+        let expected = Event { keys, data: array![] };
         self.assert_only_event(contract, expected);
     }
 
     fn assert_only_event_default_admin_delay_change_scheduled(
         ref self: EventSpy, contract: ContractAddress, new_delay: u64, effect_schedule: u64,
     ) {
-        let expected =
-            AccessControlDefaultAdminRulesComponent::Event::DefaultAdminDelayChangeScheduled(
-            DefaultAdminDelayChangeScheduled { new_delay, effect_schedule },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("DefaultAdminDelayChangeScheduled"));
+
+        let mut data = array![];
+        data.append_serde(new_delay);
+        data.append_serde(effect_schedule);
+
+        let expected = Event { keys, data };
         self.assert_only_event(contract, expected);
     }
 
     fn assert_only_event_default_admin_delay_change_canceled(
         ref self: EventSpy, contract: ContractAddress,
     ) {
-        let expected =
-            AccessControlDefaultAdminRulesComponent::Event::DefaultAdminDelayChangeCanceled(
-            DefaultAdminDelayChangeCanceled {},
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("DefaultAdminDelayChangeCanceled"));
+
+        let expected = Event { keys, data: array![] };
         self.assert_only_event(contract, expected);
     }
 }

packages/access/src/tests/test_ownable_twostep.cairo

@@ -3,7 +3,8 @@ use openzeppelin_test_common::mocks::access::DualCaseTwoStepOwnableMock;
 use openzeppelin_test_common::ownable::OwnableSpyHelpers;
 use openzeppelin_testing::constants::{NEW_OWNER, OTHER, OWNER, ZERO};
 use openzeppelin_testing::{EventSpyExt, EventSpyQueue as EventSpy, spy_events};
-use snforge_std::{start_cheat_caller_address, test_address};
+use openzeppelin_utils::serde::SerializedAppend;
+use snforge_std::{Event, start_cheat_caller_address, test_address};
 use starknet::ContractAddress;
 use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
 use crate::ownable::OwnableComponent;
@@ -291,9 +292,12 @@ impl TwoStepSpyHelpersImpl of TwoStepSpyHelpers {
         previous_owner: ContractAddress,
         new_owner: ContractAddress,
     ) {
-        let expected = OwnableComponent::Event::OwnershipTransferStarted(
-            OwnershipTransferStarted { previous_owner, new_owner },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("OwnershipTransferStarted"));
+        keys.append_serde(previous_owner);
+        keys.append_serde(new_owner);
+
+        let expected = Event { keys, data: array![] };
         self.assert_emitted_single(from_address, expected);
     }
 }

packages/governance/src/governor/governor.cairo

@@ -965,11 +965,8 @@ pub mod GovernorComponent {
             description_hash: felt252,
         ) {
             let valid_states = array![
-                ProposalState::Pending,
-                ProposalState::Active,
-                ProposalState::Defeated,
-                ProposalState::Succeeded,
-                ProposalState::Queued,
+                ProposalState::Pending, ProposalState::Active, ProposalState::Defeated,
+                ProposalState::Succeeded, ProposalState::Queued,
             ];
             self.validate_state(proposal_id, valid_states.span());
 

packages/governance/src/governor/proposal_core.cairo

@@ -84,7 +84,6 @@ mod tests {
     use core::num::traits::Bounded;
     use openzeppelin_testing::constants::ALICE;
     use openzeppelin_testing::{FuzzableBool, FuzzableContractAddress};
-    use starknet::ContractAddress;
     use super::{ProposalCore, ProposalCoreStorePacking as StorePacking};
 
     #[test]

packages/governance/src/tests/governor/block_number/test_governor_settings.cairo

@@ -1,12 +1,12 @@
 use openzeppelin_test_common::mocks::governor::GovernorTimelockedMock::SNIP12MetadataImpl;
 use openzeppelin_testing::constants::OTHER;
 use openzeppelin_testing::{EventSpyExt, EventSpyQueue as EventSpy, spy_events};
-use snforge_std::{start_cheat_caller_address, test_address};
+use openzeppelin_utils::serde::SerializedAppend;
+use snforge_std::{Event, start_cheat_caller_address, test_address};
 use starknet::ContractAddress;
 use starknet::storage::StoragePointerWriteAccess;
 use crate::governor::DefaultConfig;
 use crate::governor::GovernorComponent::InternalImpl;
-use crate::governor::extensions::GovernorSettingsComponent;
 use crate::governor::extensions::GovernorSettingsComponent::{
     GovernorSettings, GovernorSettingsAdminImpl, InternalImpl as GovernorSettingsInternalImpl,
 };
@@ -15,6 +15,7 @@ use crate::tests::governor::block_number::common::{
     set_executor,
 };
 
+
 //
 // Extensions
 //
@@ -395,9 +396,14 @@ pub(crate) impl GovernorSettingsSpyHelpersImpl of GovernorSettingsSpyHelpers {
     fn assert_event_voting_delay_updated(
         ref self: EventSpy, contract: ContractAddress, old_voting_delay: u64, new_voting_delay: u64,
     ) {
-        let expected = GovernorSettingsComponent::Event::VotingDelayUpdated(
-            GovernorSettingsComponent::VotingDelayUpdated { old_voting_delay, new_voting_delay },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("VotingDelayUpdated"));
+
+        let mut data = array![];
+        data.append_serde(old_voting_delay);
+        data.append_serde(new_voting_delay);
+
+        let expected = Event { keys, data };
         self.assert_emitted_single(contract, expected);
     }
 
@@ -414,9 +420,14 @@ pub(crate) impl GovernorSettingsSpyHelpersImpl of GovernorSettingsSpyHelpers {
         old_voting_period: u64,
         new_voting_period: u64,
     ) {
-        let expected = GovernorSettingsComponent::Event::VotingPeriodUpdated(
-            GovernorSettingsComponent::VotingPeriodUpdated { old_voting_period, new_voting_period },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("VotingPeriodUpdated"));
+
+        let mut data = array![];
+        data.append_serde(old_voting_period);
+        data.append_serde(new_voting_period);
+
+        let expected = Event { keys, data };
         self.assert_emitted_single(contract, expected);
     }
 
@@ -436,11 +447,14 @@ pub(crate) impl GovernorSettingsSpyHelpersImpl of GovernorSettingsSpyHelpers {
         old_proposal_threshold: u256,
         new_proposal_threshold: u256,
     ) {
-        let expected = GovernorSettingsComponent::Event::ProposalThresholdUpdated(
-            GovernorSettingsComponent::ProposalThresholdUpdated {
-                old_proposal_threshold, new_proposal_threshold,
-            },
-        );
+        let mut keys = array![];
+        keys.append_serde(selector!("ProposalThresholdUpdated"));
+
+        let mut data = array![];
+        data.append_serde(old_proposal_threshold);
+        data.append_serde(new_proposal_threshold);
+
+        let expected = Event { keys, data };
         self.assert_emitted_single(contract, expected);
     }