Merge "feat: transfer fees to treasury (#78)" into dev

saiintbrisson · saiintbrisson · commit 88367b86cab5 · 2025-04-06T10:28:28.000-03:00
diff --git a/pallets/governance/src/application.rs b/pallets/governance/src/application.rs
@@ -1,11 +1,7 @@
 use codec::{Decode, Encode, MaxEncodedLen};
 use polkadot_sdk::{
     frame_election_provider_support::Get,
-    frame_support::{
-        dispatch::DispatchResult,
-        traits::{Currency, WithdrawReasons},
-        DebugNoBound,
-    },
+    frame_support::{dispatch::DispatchResult, traits::Currency, DebugNoBound},
     polkadot_sdk_frame::prelude::BlockNumberFor,
     sp_runtime::BoundedVec,
     sp_std::vec::Vec,
@@ -86,10 +82,10 @@ pub fn submit_application<T: crate::Config>(
     let config = crate::GlobalGovernanceConfig::<T>::get();
     let cost = config.agent_application_cost;
 
-    let _ = <T as crate::Config>::Currency::withdraw(
+    <T as crate::Config>::Currency::transfer(
         &payer,
+        &crate::DaoTreasuryAddress::<T>::get(),
         cost,
-        WithdrawReasons::except(WithdrawReasons::TIP),
         ExistenceRequirement::AllowDeath,
     )
     .map_err(|_| crate::Error::<T>::NotEnoughBalanceToApply)?;
@@ -161,8 +157,12 @@ pub fn accept_application<T: crate::Config>(application_id: u32) -> DispatchResu
     });
 
     // Give the application fee back to the payer key.
-    let _ =
-        <T as crate::Config>::Currency::deposit_creating(&application.payer_key, application.cost);
+    let _ = <T as crate::Config>::Currency::transfer(
+        &crate::DaoTreasuryAddress::<T>::get(),
+        &application.payer_key,
+        application.cost,
+        ExistenceRequirement::AllowDeath,
+    );
 
     crate::Pallet::<T>::deposit_event(crate::Event::<T>::ApplicationAccepted(application.id));
 
@@ -184,8 +184,6 @@ pub fn deny_application<T: crate::Config>(application_id: u32) -> DispatchResult
         }
     });
 
-    // Application cost is discarded
-
     crate::Pallet::<T>::deposit_event(crate::Event::<T>::ApplicationDenied(application.id));
 
     Ok(())
diff --git a/pallets/governance/src/proposal.rs b/pallets/governance/src/proposal.rs
@@ -2,10 +2,7 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use polkadot_sdk::{
     frame_election_provider_support::Get,
     frame_support::{
-        dispatch::DispatchResult,
-        ensure,
-        storage::with_storage_layer,
-        traits::{Currency, WithdrawReasons},
+        dispatch::DispatchResult, ensure, storage::with_storage_layer, traits::Currency,
     },
     polkadot_sdk_frame::{prelude::BlockNumberFor, traits::CheckedAdd},
     sp_core::{ConstU32, U256},
@@ -89,8 +86,12 @@ impl<T: crate::Config> Proposal<T> {
     /// Executes the changes.
     fn execute_proposal(self) -> DispatchResult {
         // Proposal fee is given back to the proposer.
-        let _ =
-            <T as crate::Config>::Currency::deposit_creating(&self.proposer, self.proposal_cost);
+        let _ = <T as crate::Config>::Currency::transfer(
+            &crate::DaoTreasuryAddress::<T>::get(),
+            &self.proposer,
+            self.proposal_cost,
+            ExistenceRequirement::AllowDeath,
+        );
 
         match self.data {
             ProposalData::GlobalParams(data) => {
@@ -415,13 +416,13 @@ fn add_proposal<T: crate::Config>(
     let config = GlobalGovernanceConfig::<T>::get();
 
     let cost = config.proposal_cost;
-    let _ = <T as crate::Config>::Currency::withdraw(
+    <T as crate::Config>::Currency::transfer(
         &proposer,
+        &crate::DaoTreasuryAddress::<T>::get(),
         cost,
-        WithdrawReasons::except(WithdrawReasons::TIP),
         ExistenceRequirement::AllowDeath,
     )
-    .map_err(|_| crate::Error::<T>::NotEnoughBalanceToPropose)?;
+    .map_err(|_| crate::Error::<T>::NotEnoughBalanceToApply)?;
 
     let proposal_id: u64 = crate::Proposals::<T>::iter()
         .count()
diff --git a/pallets/governance/tests/application.rs b/pallets/governance/tests/application.rs
@@ -1,7 +1,11 @@
+use pallet_emission0::PendingEmission;
 use pallet_governance::{
     application::ApplicationStatus, AgentApplications, GlobalGovernanceConfig, Whitelist,
 };
+use pallet_governance::{DaoTreasuryAddress, TreasuryEmissionFee};
+use pallet_governance_api::GovernanceApi;
 use polkadot_sdk::frame_support::assert_err;
+use polkadot_sdk::sp_runtime::Percent;
 use test_utils::*;
 
 #[test]
@@ -205,6 +209,10 @@ fn error_is_thrown_on_multiple_applications_same_key() {
 #[test]
 fn application_denied_doesnt_add_to_whitelist() {
     new_test_ext().execute_with(|| {
+        PendingEmission::<Test>::set(0);
+        TreasuryEmissionFee::<Test>::set(Percent::zero());
+        let balance = get_balance(DaoTreasuryAddress::<Test>::get());
+
         let key = 0;
         let adding_key = 1;
         pallet_governance::Curators::<Test>::insert(key, ());
@@ -251,6 +259,10 @@ fn application_denied_doesnt_add_to_whitelist() {
             application.status,
             ApplicationStatus::Resolved { accepted: false }
         );
+        assert_eq!(
+            get_balance(Governance::dao_treasury_address()),
+            balance + crate::GlobalGovernanceConfig::<Test>::get().agent_application_cost
+        );
     });
 }
 
@@ -263,6 +275,10 @@ fn application_expires() {
                 config.agent_application_expiration
             });
 
+        PendingEmission::<Test>::set(0);
+        TreasuryEmissionFee::<Test>::set(Percent::zero());
+        let balance = get_balance(DaoTreasuryAddress::<Test>::get());
+
         let key = 0;
         let adding_key = 1;
         pallet_governance::Curators::<Test>::insert(key, ());
@@ -291,6 +307,10 @@ fn application_expires() {
         let application =
             pallet_governance::AgentApplications::<Test>::get(application_id).unwrap();
         assert_eq!(application.status, ApplicationStatus::Expired);
+        assert_eq!(
+            get_balance(Governance::dao_treasury_address()),
+            balance + crate::GlobalGovernanceConfig::<Test>::get().agent_application_cost
+        );
     });
 }
 
diff --git a/pallets/governance/tests/voting.rs b/pallets/governance/tests/voting.rs
@@ -1,10 +1,15 @@
-use pallet_governance::proposal::{Proposal, ProposalData};
-use pallet_governance::Error;
-use pallet_governance::{proposal::ProposalStatus, Proposals};
-use polkadot_sdk::frame_support::{assert_err, assert_ok};
-use polkadot_sdk::sp_runtime::BoundedVec;
+use pallet_emission0::PendingEmission;
+use pallet_governance::{
+    proposal::{Proposal, ProposalData, ProposalStatus},
+    DaoTreasuryAddress, Error, GlobalGovernanceConfig, Proposals, TreasuryEmissionFee,
+};
+use pallet_governance_api::GovernanceApi;
+use polkadot_sdk::frame_support::assert_err;
+use polkadot_sdk::{frame_support::assert_ok, sp_runtime::Percent};
+use polkadot_sdk::{frame_support::traits::Get, sp_runtime::BoundedVec};
 use test_utils::{
-    add_balance, get_balance, get_origin, new_test_ext, to_nano, zero_min_burn, AccountId, Test,
+    add_balance, get_balance, get_origin, new_test_ext, step_block, to_nano, zero_min_burn,
+    AccountId, Governance, Test,
 };
 
 fn register(account: AccountId, _unused: u16, module: AccountId, stake: u128) {
@@ -74,7 +79,49 @@ fn removes_vote_correctly() {
         const FOR: u32 = 0;
         const AGAINST: u32 = 1;
 
+        let key = 0;
+
         register(FOR, 0, 0, to_nano(10));
+        register(AGAINST, 0, 1, to_nano(5));
+
+        config(1, 100);
+
+        add_balance(key, 1);
+        assert_ok!(
+            pallet_governance::Pallet::<Test>::add_global_custom_proposal(
+                get_origin(key),
+                b"metadata".to_vec()
+            )
+        );
+
+        vote(FOR, 0, true);
+        vote(AGAINST, 0, false);
+
+        step_block(100);
+
+        assert_eq!(
+            Proposals::<Test>::get(0).unwrap().status,
+            ProposalStatus::Accepted {
+                block: 100,
+                stake_for: to_nano(10),
+                stake_against: to_nano(5),
+            }
+        );
+    });
+}
+
+#[test]
+fn global_proposal_is_refused_correctly() {
+    new_test_ext().execute_with(|| {
+        PendingEmission::<Test>::set(0);
+        TreasuryEmissionFee::<Test>::set(Percent::zero());
+        let balance = get_balance(DaoTreasuryAddress::<Test>::get());
+
+        zero_min_burn();
+        const FOR: u32 = 0;
+        const AGAINST: u32 = 1;
+
+        register(FOR, 0, 0, to_nano(5));
         register(AGAINST, 0, 1, to_nano(10));
 
         config(1, 100);
@@ -103,6 +150,11 @@ fn removes_vote_correctly() {
             }
             _ => unreachable!(),
         }
+
+        assert_eq!(
+            get_balance(Governance::dao_treasury_address()),
+            balance + crate::GlobalGovernanceConfig::<Test>::get().proposal_cost
+        );
     });
 }
 
@@ -149,27 +201,80 @@ fn ensures_proposal_exists() {
         zero_min_burn();
 
         const MODULE: u32 = 0;
+        PendingEmission::<Test>::set(0);
+        TreasuryEmissionFee::<Test>::set(Percent::zero());
+        let balance = get_balance(DaoTreasuryAddress::<Test>::get());
 
-        register(MODULE, 0, 0, to_nano(10));
+        let min_stake: u128 = <Test as pallet_torus0::Config>::DefaultMinAllowedStake::get();
+        let default_proposal_expiration: u64 =
+            <Test as pallet_governance::Config>::DefaultProposalExpiration::get();
 
         config(1, 100);
 
+        let origin = get_origin(0);
+        add_balance(0, to_nano(2));
+        register(0, 0, 0, to_nano(1) - min_stake);
+
         if pallet_torus0::stake::sum_staked_by::<Test>(&MODULE) < 1 {
             stake(MODULE, MODULE, to_nano(1));
         }
 
+        let _ = pallet_governance::roles::penalize_agent::<Test>(0, 100);
+        pallet_torus0::TotalStake::<Test>::set(to_nano(10));
+
+        assert_ok!(pallet_governance::Pallet::<Test>::add_emission_proposal(
+            origin.clone(),
+            Percent::from_parts(20),
+            Percent::from_parts(20),
+            Percent::from_parts(20),
+            vec![b'0'; 64],
+        ));
+
+        vote(0, 0, true);
+
+        step_block(default_proposal_expiration);
+
+        assert_eq!(
+            Proposals::<Test>::get(0).unwrap().status,
+            ProposalStatus::Expired
+        );
+        assert_eq!(
+            get_balance(Governance::dao_treasury_address()),
+            balance + crate::GlobalGovernanceConfig::<Test>::get().proposal_cost
+        );
+    });
+}
+
+#[test]
+fn creates_emission_proposal_with_invalid_params_and_it_fails() {
+    new_test_ext().execute_with(|| {
+        const MODULE: AccountId = 0;
+
+        zero_min_burn();
+
+        let default_proposal_expiration: u64 =
+            <Test as pallet_governance::Config>::DefaultProposalExpiration::get();
+
+        let min_stake: u128 = <Test as pallet_torus0::Config>::DefaultMinAllowedStake::get();
+
+        config(1, default_proposal_expiration);
+
+        let origin = get_origin(MODULE);
+        add_balance(MODULE, to_nano(2));
+        register(MODULE, 0, MODULE, to_nano(1) - min_stake);
+
         assert_err!(
-            pallet_governance::Pallet::<Test>::vote_proposal(get_origin(MODULE), 0, true),
+            pallet_governance::Pallet::<Test>::vote_proposal(origin.clone(), 0, true),
             Error::<Test>::ProposalNotFound
         );
 
         assert_err!(
-            pallet_governance::Pallet::<Test>::vote_proposal(get_origin(MODULE), 0, false),
+            pallet_governance::Pallet::<Test>::vote_proposal(origin.clone(), 0, false),
             Error::<Test>::ProposalNotFound
         );
 
         assert_err!(
-            pallet_governance::Pallet::<Test>::remove_vote_proposal(get_origin(MODULE), 0),
+            pallet_governance::Pallet::<Test>::remove_vote_proposal(origin, 0),
             Error::<Test>::ProposalNotFound
         );
     });
diff --git a/pallets/torus0/src/agent.rs b/pallets/torus0/src/agent.rs
@@ -6,7 +6,7 @@ use polkadot_sdk::{
     frame_support::{
         dispatch::DispatchResult,
         ensure,
-        traits::{Currency, ExistenceRequirement, WithdrawReasons},
+        traits::{Currency, ExistenceRequirement},
         DebugNoBound,
     },
     polkadot_sdk_frame::prelude::BlockNumberFor,
@@ -101,10 +101,11 @@ pub fn register<T: crate::Config>(
 
     let burn = crate::Burn::<T>::get();
 
-    let _ = <T as crate::Config>::Currency::withdraw(
+    // Registration cost is sent to treasury
+    <T as crate::Config>::Currency::transfer(
         &payer,
+        &<T as crate::Config>::Governance::dao_treasury_address(),
         burn,
-        WithdrawReasons::except(WithdrawReasons::TIP),
         ExistenceRequirement::AllowDeath,
     )
     .map_err(|_| crate::Error::<T>::NotEnoughBalanceToRegisterAgent)?;
diff --git a/pallets/torus0/tests/agent.rs b/pallets/torus0/tests/agent.rs
@@ -1,20 +1,26 @@
+use pallet_governance_api::GovernanceApi;
 use pallet_torus0::{
     agent::Agent, AgentUpdateCooldown, Agents, Burn, Error, ImmunityPeriod, MaxAllowedAgents,
 };
 use polkadot_sdk::{frame_support::assert_err, sp_core::Get, sp_runtime::Percent};
 use test_utils::{
-    assert_ok, clear_cooldown, get_origin,
-    pallet_emission0::{ConsensusMembers, WeightControlDelegation},
-    pallet_governance::{self, Allocators},
-    step_block, Test,
+    assert_ok, clear_cooldown, get_balance, get_origin,
+    pallet_emission0::{ConsensusMembers, PendingEmission, WeightControlDelegation},
+    pallet_governance::{self, Allocators, DaoTreasuryAddress, TreasuryEmissionFee},
+    step_block, Governance, Test,
 };
 
 #[test]
 fn register_correctly() {
     test_utils::new_test_ext().execute_with(|| {
+        PendingEmission::<Test>::set(0);
+        TreasuryEmissionFee::<Test>::set(Percent::zero());
+        let balance = get_balance(DaoTreasuryAddress::<Test>::get());
+
         let agent_id = 0;
         let allocator_id = 1;
-        let name = "agent".as_bytes().to_vec();
+
+        let name = "idk://agent".as_bytes().to_vec();
         let url = "idk://agent".as_bytes().to_vec();
         let metadata = "idk://agent".as_bytes().to_vec();
 
@@ -67,6 +73,11 @@ fn register_correctly() {
             ),
             Error::<Test>::AgentAlreadyRegistered
         );
+
+        assert_eq!(
+            get_balance(Governance::dao_treasury_address()),
+            balance + Burn::<Test>::get()
+        );
     });
 }
 
