Add Governor component

Scarb.lock

@@ -165,15 +165,15 @@ dependencies = [
 
 [[package]]
 name = "snforge_scarb_plugin"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://scarbs.xyz/"
-checksum = "sha256:1fce075fcbf7fce1b0935f6f9a034549704837fb221da212d3b6e9134cebfdaa"
+checksum = "sha256:e5a0e80294b1f5f00955c614ee3fc94c843ff0d27935693c3598d0ac8d79250a"
 
 [[package]]
 name = "snforge_std"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://scarbs.xyz/"
-checksum = "sha256:60ac980b297281f9a59a5f1668cb56bdea1b28fd2f8008008270f9a3c91ad3ba"
+checksum = "sha256:0e3cb45c6276334fd142a77212f0592d55744f1c022b7a63f20bcd79d0ce3927"
 dependencies = [
  "snforge_scarb_plugin",
 ]

Scarb.toml

@@ -42,7 +42,7 @@ keywords = [
 [workspace.dependencies]
 assert_macros = "2.8.4"
 starknet = "2.8.4"
-snforge_std = "0.31.0"
+snforge_std = "0.32.0"
 
 [dependencies]
 starknet.workspace = true

packages/governance/Scarb.toml

@@ -46,6 +46,7 @@ casm = false
 name = "openzeppelin_governance_unittest"
 build-external-contracts = [
     "openzeppelin_test_common::mocks::account::SnakeAccountMock",
+    "openzeppelin_test_common::mocks::governor::GovernorMock",
     "openzeppelin_test_common::mocks::timelock::TimelockControllerMock",
     "openzeppelin_test_common::mocks::timelock::MockContract",
     "openzeppelin_test_common::mocks::timelock::TimelockAttackerMock",

packages/governance/src/governor.cairo

@@ -0,0 +1,7 @@
+pub mod extensions;
+pub mod governor;
+pub mod interface;
+pub mod proposal_core;
+
+pub use governor::{GovernorComponent, DefaultConfig};
+pub use proposal_core::ProposalCore;

packages/governance/src/governor/extensions.cairo

@@ -0,0 +1,14 @@
+pub mod governor_core_execution;
+pub mod governor_counting_simple;
+pub mod governor_settings;
+pub mod governor_timelock_execution;
+pub mod governor_votes;
+pub mod governor_votes_quorum_fraction;
+pub mod interface;
+
+pub use governor_core_execution::GovernorCoreExecutionComponent;
+pub use governor_counting_simple::GovernorCountingSimpleComponent;
+pub use governor_settings::GovernorSettingsComponent;
+pub use governor_timelock_execution::GovernorTimelockExecutionComponent;
+pub use governor_votes::GovernorVotesComponent;
+pub use governor_votes_quorum_fraction::GovernorVotesQuorumFractionComponent;

packages/governance/src/governor/extensions/governor_core_execution.cairo

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts for Cairo v0.19.0
+// (governance/governor/extensions/governor_core_execution.cairo)
+
+/// # GovernorCoreExecution Component
+///
+/// Extension of GovernorComponent providing an execution mechanism directly through
+/// the Governor itself. For a timelocked execution mechanism, see
+/// GovernorTimelockExecutionComponent.
+#[starknet::component]
+pub mod GovernorCoreExecutionComponent {
+    use crate::governor::GovernorComponent::{
+        InternalExtendedTrait, ComponentState as GovernorComponentState
+    };
+    use crate::governor::GovernorComponent;
+    use crate::governor::interface::ProposalState;
+    use openzeppelin_introspection::src5::SRC5Component;
+    use starknet::account::Call;
+    use starknet::{ContractAddress, SyscallResultTrait};
+
+    #[storage]
+    pub struct Storage {}
+
+    //
+    // Extensions
+    //
+
+    pub impl GovernorExecution<
+        TContractState,
+        +GovernorComponent::HasComponent<TContractState>,
+        +GovernorComponent::GovernorCountingTrait<TContractState>,
+        +GovernorComponent::GovernorSettingsTrait<TContractState>,
+        +GovernorComponent::GovernorVotesTrait<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        impl GovernorCoreExecution: HasComponent<TContractState>,
+        +Drop<TContractState>
+    > of GovernorComponent::GovernorExecutionTrait<TContractState> {
+        /// See `GovernorComponent::GovernorExecutionTrait::state`.
+        fn state(
+            self: @GovernorComponentState<TContractState>, proposal_id: felt252
+        ) -> ProposalState {
+            self._state(proposal_id)
+        }
+
+        /// See `GovernorComponent::GovernorExecutionTrait::executor`.
+        fn executor(self: @GovernorComponentState<TContractState>) -> ContractAddress {
+            starknet::get_contract_address()
+        }
+
+        /// See `GovernorComponent::GovernorExecutionTrait::execute_operations`.
+        fn execute_operations(
+            ref self: GovernorComponentState<TContractState>,
+            proposal_id: felt252,
+            calls: Span<Call>,
+            description_hash: felt252
+        ) {
+            for call in calls {
+                let Call { to, selector, calldata } = *call;
+                starknet::syscalls::call_contract_syscall(to, selector, calldata).unwrap_syscall();
+            };
+        }
+
+        /// See `GovernorComponent::GovernorExecutionTrait::queue_operations`.
+        fn queue_operations(
+            ref self: GovernorComponentState<TContractState>,
+            proposal_id: felt252,
+            calls: Span<Call>,
+            description_hash: felt252
+        ) -> u64 {
+            0
+        }
+
+        /// See `GovernorComponent::GovernorExecutionTrait::proposal_needs_queuing`.
+        fn proposal_needs_queuing(
+            self: @GovernorComponentState<TContractState>, proposal_id: felt252
+        ) -> bool {
+            false
+        }
+
+        /// See `GovernorComponent::GovernorExecutionTrait::cancel_operations`.
+        fn cancel_operations(
+            ref self: GovernorComponentState<TContractState>,
+            proposal_id: felt252,
+            description_hash: felt252
+        ) {
+            self._cancel(proposal_id, description_hash);
+        }
+    }
+}

packages/governance/src/governor/extensions/governor_counting_simple.cairo

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts for Cairo v0.19.0
+// (governance/governor/extensions/governor_counting_simple.cairo)
+
+/// # GovernorCountingSimple Component
+///
+/// Extension of GovernorComponent for simple, 3 options, vote counting.
+#[starknet::component]
+pub mod GovernorCountingSimpleComponent {
+    use crate::governor::GovernorComponent::{
+        InternalTrait, ComponentState as GovernorComponentState
+    };
+    use crate::governor::GovernorComponent;
+    use openzeppelin_introspection::src5::SRC5Component;
+    use starknet::ContractAddress;
+    use starknet::storage::{Map, StoragePathEntry, StorageMapReadAccess, StorageMapWriteAccess};
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    type ProposalId = felt252;
+
+    #[storage]
+    pub struct Storage {
+        pub Governor_proposals_votes: Map<ProposalId, ProposalVote>,
+    }
+
+    /// Supported vote types.
+    pub enum VoteType {
+        Against,
+        For,
+        Abstain,
+    }
+
+    impl U8TryIntoVoteType of TryInto<u8, VoteType> {
+        fn try_into(self: u8) -> Option<VoteType> {
+            match self {
+                0 => Option::Some(VoteType::Against),
+                1 => Option::Some(VoteType::For),
+                2 => Option::Some(VoteType::Abstain),
+                _ => Option::None,
+            }
+        }
+    }
+
+    #[starknet::storage_node]
+    pub struct ProposalVote {
+        pub against_votes: u256,
+        pub for_votes: u256,
+        pub abstain_votes: u256,
+        pub has_voted: Map<ContractAddress, bool>
+    }
+
+    mod Errors {
+        pub const ALREADY_CAST_VOTE: felt252 = 'Already cast vote';
+        pub const INVALID_VOTE_TYPE: felt252 = 'Invalid vote type';
+    }
+
+    //
+    // Extensions
+    //
+
+    pub impl GovernorCounting<
+        TContractState,
+        +GovernorComponent::HasComponent<TContractState>,
+        +GovernorComponent::GovernorQuorumTrait<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        impl GovernorCountingSimple: HasComponent<TContractState>,
+        +Drop<TContractState>
+    > of GovernorComponent::GovernorCountingTrait<TContractState> {
+        /// See `GovernorComponent::GovernorCountingTrait::counting_mode`.
+        fn counting_mode(self: @GovernorComponentState<TContractState>) -> ByteArray {
+            return "support=bravo&quorum=for,abstain";
+        }
+
+        /// See `GovernorComponent::GovernorCountingTrait::count_vote`.
+        ///
+        /// In this module, the support follows the `VoteType` enum (from Governor Bravo).
+        fn count_vote(
+            ref self: GovernorComponentState<TContractState>,
+            proposal_id: felt252,
+            account: ContractAddress,
+            support: u8,
+            total_weight: u256,
+            params: @ByteArray
+        ) -> u256 {
+            let mut contract = self.get_contract_mut();
+            let mut this_component = GovernorCountingSimple::get_component_mut(ref contract);
+
+            let proposal_votes = this_component.Governor_proposals_votes.entry(proposal_id);
+            assert(!proposal_votes.has_voted.read(account), Errors::ALREADY_CAST_VOTE);
+
+            proposal_votes.has_voted.write(account, true);
+
+            let support: VoteType = support.try_into().expect(Errors::INVALID_VOTE_TYPE);
+            match support {
+                VoteType::Against => {
+                    let current_votes = proposal_votes.against_votes.read();
+                    proposal_votes.against_votes.write(current_votes + total_weight);
+                },
+                VoteType::For => {
+                    let current_votes = proposal_votes.for_votes.read();
+                    proposal_votes.for_votes.write(current_votes + total_weight);
+                },
+                VoteType::Abstain => {
+                    let current_votes = proposal_votes.abstain_votes.read();
+                    proposal_votes.abstain_votes.write(current_votes + total_weight);
+                }
+            }
+            total_weight
+        }
+
+        /// See `GovernorComponent::GovernorCountingTrait::has_voted`.
+        fn has_voted(
+            self: @GovernorComponentState<TContractState>,
+            proposal_id: felt252,
+            account: ContractAddress
+        ) -> bool {
+            let contract = self.get_contract();
+            let this_component = GovernorCountingSimple::get_component(contract);
+            let proposal_votes = this_component.Governor_proposals_votes.entry(proposal_id);
+
+            proposal_votes.has_voted.read(account)
+        }
+
+        /// See `GovernorComponent::GovernorCountingTrait::quorum_reached`.
+        fn quorum_reached(
+            self: @GovernorComponentState<TContractState>, proposal_id: felt252
+        ) -> bool {
+            let contract = self.get_contract();
+            let this_component = GovernorCountingSimple::get_component(contract);
+
+            let proposal_votes = this_component.Governor_proposals_votes.entry(proposal_id);
+            let snapshot = self._proposal_snapshot(proposal_id);
+
+            self.quorum(snapshot) <= proposal_votes.for_votes.read()
+                + proposal_votes.abstain_votes.read()
+        }
+
+        /// See `GovernorComponent::GovernorCountingTrait::vote_succeeded`.
+        ///
+        /// In this module, the `for_votes` must be strictly over the `against_votes`.
+        fn vote_succeeded(
+            self: @GovernorComponentState<TContractState>, proposal_id: felt252
+        ) -> bool {
+            let contract = self.get_contract();
+            let this_component = GovernorCountingSimple::get_component(contract);
+            let proposal_votes = this_component.Governor_proposals_votes.entry(proposal_id);
+
+            proposal_votes.for_votes.read() > proposal_votes.against_votes.read()
+        }
+    }
+}