Governance base contract

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "examples/fungible-blocklist",
     "examples/fungible-capped",
     "examples/fungible-merkle-airdrop",
+    "examples/fungible-governor",
     "examples/fungible-votes",
     "examples/fee-forwarder-permissioned",
     "examples/fee-forwarder-permissionless",

examples/fungible-governor/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "fungible-governor-example"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+version.workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+stellar-access = { workspace = true }
+stellar-governance = { workspace = true }
+stellar-macros = { workspace = true }
+stellar-tokens = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }

examples/fungible-governor/src/governor.rs

@@ -0,0 +1,68 @@
+use soroban_sdk::{contract, contractimpl, Address, BytesN, Env, String, Symbol, Val, Vec};
+use stellar_governance::governor::{
+    storage::{self, set_token_contract},
+    Governor, ProposalState,
+};
+
+#[contract]
+pub struct GovernorContract;
+
+#[contractimpl]
+impl GovernorContract {
+    pub fn __constructor(
+        e: &Env,
+        token_contract: Address,
+        voting_delay: u32,
+        voting_period: u32,
+        proposal_threshold: u128,
+        quorum: u128,
+    ) {
+        storage::set_name(e, String::from_str(e, "ExampleGovernor"));
+        storage::set_version(e, String::from_str(e, "1.0.0"));
+        set_token_contract(e, &token_contract);
+        storage::set_voting_delay(e, voting_delay);
+        storage::set_voting_period(e, voting_period);
+        storage::set_proposal_threshold(e, proposal_threshold);
+        storage::set_quorum(e, quorum);
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl Governor for GovernorContract {
+    fn execute(
+        e: &Env,
+        targets: Vec<Address>,
+        functions: Vec<Symbol>,
+        args: Vec<Vec<Val>>,
+        description_hash: BytesN<32>,
+        executor: Address,
+    ) -> BytesN<32> {
+        // Open execution: any account can trigger a succeeded proposal,
+        // as long as they authenticate themselves as `executor`.
+        executor.require_auth();
+        storage::execute(
+            e,
+            targets,
+            functions,
+            args,
+            &description_hash,
+            Self::proposal_needs_queuing(e),
+        )
+    }
+
+    fn cancel(
+        e: &Env,
+        targets: Vec<Address>,
+        functions: Vec<Symbol>,
+        args: Vec<Vec<Val>>,
+        description_hash: BytesN<32>,
+        operator: Address,
+    ) -> BytesN<32> {
+        // Restricted cancellation: only the original proposer can cancel.
+        let proposal_id = storage::hash_proposal(e, &targets, &functions, &args, &description_hash);
+        let proposer = storage::get_proposal_proposer(e, &proposal_id);
+        assert!(operator == proposer);
+        operator.require_auth();
+        storage::cancel(e, targets, functions, args, &description_hash)
+    }
+}

examples/fungible-governor/src/lib.rs

@@ -0,0 +1,10 @@
+#![no_std]
+
+mod governor;
+mod token;
+
+#[cfg(test)]
+mod test;
+
+pub use governor::*;
+pub use token::*;