feat: add cooldown and event to agent update extrinsic (#88)

Closes CHAIN-66

---------

Co-authored-by: Luiz Carvalho <[email protected]>

Author: devwckd

pallets/governance/src/migrations.rs

@@ -5,13 +5,127 @@ use polkadot_sdk::frame_support::{
 use crate::{Config, Pallet};
 
 pub mod v3 {
+    use crate::proposal::{GlobalParamsData, ProposalData};
+
     use super::*;
 
     pub type Migration<T, W> = VersionedMigration<2, 3, MigrateToV3<T>, Pallet<T>, W>;
     pub struct MigrateToV3<T>(core::marker::PhantomData<T>);
 
+    mod old_storage {
+        use codec::{Decode, Encode, MaxEncodedLen};
+        use polkadot_sdk::{
+            frame_support::{storage_alias, DebugNoBound, Identity},
+            polkadot_sdk_frame::prelude::BlockNumberFor,
+            sp_core::ConstU32,
+            sp_runtime::{BoundedVec, Percent},
+        };
+        use scale_info::TypeInfo;
+
+        use crate::{
+            proposal::{ProposalId, ProposalStatus},
+            AccountIdOf, BalanceOf,
+        };
+
+        #[derive(Clone, DebugNoBound, TypeInfo, Decode, Encode, MaxEncodedLen)]
+        #[scale_info(skip_type_params(T))]
+        pub struct Proposal<T: crate::Config> {
+            pub id: ProposalId,
+            pub proposer: AccountIdOf<T>,
+            pub expiration_block: BlockNumberFor<T>,
+            pub data: ProposalData<T>,
+            pub status: ProposalStatus<T>,
+            pub metadata: BoundedVec<u8, ConstU32<256>>,
+            pub proposal_cost: BalanceOf<T>,
+            pub creation_block: BlockNumberFor<T>,
+        }
+
+        #[derive(Clone, DebugNoBound, TypeInfo, Decode, Encode, MaxEncodedLen, PartialEq, Eq)]
+        #[scale_info(skip_type_params(T))]
+        pub enum ProposalData<T: crate::Config> {
+            GlobalParams(GlobalParamsData<T>),
+            GlobalCustom,
+            Emission {
+                recycling_percentage: Percent,
+                treasury_percentage: Percent,
+                incentives_ratio: Percent,
+            },
+            TransferDaoTreasury {
+                account: AccountIdOf<T>,
+                amount: BalanceOf<T>,
+            },
+        }
+
+        #[derive(Clone, DebugNoBound, TypeInfo, Decode, Encode, MaxEncodedLen, PartialEq, Eq)]
+        #[scale_info(skip_type_params(T))]
+        pub struct GlobalParamsData<T: crate::Config> {
+            pub min_name_length: u16,
+            pub max_name_length: u16,
+            pub max_allowed_agents: u16,
+            pub max_allowed_weights: u16,
+            pub min_stake_per_weight: BalanceOf<T>,
+            pub min_weight_control_fee: u8,
+            pub min_staking_fee: u8,
+            pub dividends_participation_weight: Percent,
+            pub proposal_cost: BalanceOf<T>,
+        }
+
+        #[storage_alias]
+        pub type Proposals<T: crate::Config> =
+            StorageMap<crate::Pallet<T>, Identity, ProposalId, Proposal<T>>;
+    }
+
     impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV3<T> {
         fn on_runtime_upgrade() -> Weight {
+            for (id, proposal) in old_storage::Proposals::iter() {
+                let new_data = match proposal.data {
+                    old_storage::ProposalData::GlobalParams(old_storage::GlobalParamsData {
+                        min_name_length,
+                        max_name_length,
+                        max_allowed_agents,
+                        min_weight_control_fee,
+                        min_staking_fee,
+                        dividends_participation_weight,
+                        proposal_cost,
+                        ..
+                    }) => ProposalData::GlobalParams(GlobalParamsData {
+                        min_name_length,
+                        max_name_length,
+                        max_allowed_agents,
+                        min_weight_control_fee,
+                        min_staking_fee,
+                        dividends_participation_weight,
+                        proposal_cost,
+                    }),
+                    old_storage::ProposalData::GlobalCustom => ProposalData::GlobalCustom,
+                    old_storage::ProposalData::Emission {
+                        recycling_percentage,
+                        treasury_percentage,
+                        incentives_ratio,
+                    } => ProposalData::Emission {
+                        recycling_percentage,
+                        treasury_percentage,
+                        incentives_ratio,
+                    },
+                    old_storage::ProposalData::TransferDaoTreasury { account, amount } => {
+                        ProposalData::TransferDaoTreasury { account, amount }
+                    }
+                };
+
+                let new_proposal = crate::proposal::Proposal {
+                    id: proposal.id,
+                    proposer: proposal.proposer,
+                    expiration_block: proposal.expiration_block,
+                    data: new_data,
+                    status: proposal.status,
+                    metadata: proposal.metadata,
+                    proposal_cost: proposal.proposal_cost,
+                    creation_block: proposal.creation_block,
+                };
+
+                crate::Proposals::<T>::set(id, Some(new_proposal));
+            }
+
             Weight::zero()
         }
     }

pallets/torus0/src/agent.rs

@@ -36,6 +36,7 @@ pub struct Agent<T: crate::Config> {
     pub weight_penalty_factor: Percent,
     pub registration_block: BlockNumberFor<T>,
     pub fees: crate::fee::ValidatorFee<T>,
+    pub last_update_block: BlockNumberFor<T>,
 }
 
 /// Register an agent to the given key, payed by the payer key.
@@ -108,6 +109,7 @@ pub fn register<T: crate::Config>(
     )
     .map_err(|_| crate::Error::<T>::NotEnoughBalanceToRegisterAgent)?;
 
+    let registration_block = <polkadot_sdk::frame_system::Pallet<T>>::block_number();
     crate::Agents::<T>::insert(
         agent_key.clone(),
         Agent {
@@ -116,8 +118,9 @@ pub fn register<T: crate::Config>(
             url: BoundedVec::truncate_from(url),
             metadata: BoundedVec::truncate_from(metadata),
             weight_penalty_factor: Percent::from_percent(0),
-            registration_block: <polkadot_sdk::frame_system::Pallet<T>>::block_number(),
+            registration_block,
             fees: Default::default(),
+            last_update_block: registration_block,
         },
     );
 
@@ -177,6 +180,10 @@ pub fn update<T: crate::Config>(
             return Err(crate::Error::<T>::AgentDoesNotExist.into());
         };
 
+        if is_in_update_cooldown::<T>(&agent_key)? {
+            return Err(crate::Error::<T>::AgentUpdateOnCooldown.into());
+        }
+
         validate_agent_name::<T>(&name[..])?;
         agent.name = BoundedVec::truncate_from(name);
 
@@ -211,9 +218,35 @@ pub fn update<T: crate::Config>(
         Ok::<(), DispatchError>(())
     })?;
 
+    set_in_cooldown::<T>(&agent_key)?;
+    crate::Pallet::<T>::deposit_event(crate::Event::<T>::AgentUpdated(agent_key));
+
     Ok(())
 }
 
+fn is_in_update_cooldown<T: crate::Config>(key: &AccountIdOf<T>) -> Result<bool, DispatchError> {
+    let current_block = <polkadot_sdk::frame_system::Pallet<T>>::block_number();
+    let cooldown = crate::AgentUpdateCooldown::<T>::get();
+
+    let last_update = crate::Agents::<T>::get(key)
+        .ok_or(crate::Error::<T>::AgentDoesNotExist)?
+        .last_update_block;
+
+    Ok(last_update + cooldown > current_block)
+}
+
+fn set_in_cooldown<T: crate::Config>(key: &AccountIdOf<T>) -> DispatchResult {
+    crate::Agents::<T>::mutate(key, |agent| {
+        let Some(agent) = agent else {
+            return Err(crate::Error::<T>::AgentDoesNotExist.into());
+        };
+
+        agent.last_update_block = <polkadot_sdk::frame_system::Pallet<T>>::block_number();
+
+        Ok(())
+    })
+}
+
 pub fn exists<T: crate::Config>(key: &AccountIdOf<T>) -> bool {
     crate::Agents::<T>::contains_key(key)
 }

pallets/torus0/src/lib.rs

@@ -8,7 +8,10 @@ pub mod migrations;
 pub mod stake;
 
 pub(crate) use ext::*;
-use frame::{arithmetic::Percent, prelude::ensure_signed};
+use frame::{
+    arithmetic::Percent,
+    prelude::{ensure_root, ensure_signed},
+};
 pub use pallet::*;
 use polkadot_sdk::{
     frame_support::{
@@ -26,7 +29,7 @@ use crate::{agent::Agent, burn::BurnConfiguration, fee::ValidatorFeeConstraints}
 
 #[frame::pallet]
 pub mod pallet {
-    const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+    const STORAGE_VERSION: StorageVersion = StorageVersion::new(3);
 
     use frame::prelude::BlockNumberFor;
     use pallet_emission0_api::Emission0Api;
@@ -132,6 +135,11 @@ pub mod pallet {
     #[pallet::storage]
     pub type BurnConfig<T: Config> = StorageValue<_, BurnConfiguration<T>, ValueQuery>;
 
+    /// Cooldown (in blocks) in which an agent needs to wait between each `update_agent` call.
+    #[pallet::storage]
+    pub type AgentUpdateCooldown<T: Config> =
+        StorageValue<_, BlockNumberFor<T>, ValueQuery, T::DefaultAgentUpdateCooldown>;
+
     #[pallet::hooks]
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
         fn on_initialize(block_number: BlockNumberFor<T>) -> Weight {
@@ -228,6 +236,11 @@ pub mod pallet {
         #[pallet::constant]
         type DefaultDividendsParticipationWeight: Get<Percent>;
 
+        /// Default Cooldown (in blocks) in which an agent needs to wait between each `update_agent` call.
+        #[pallet::constant]
+        #[pallet::no_default_bounds]
+        type DefaultAgentUpdateCooldown: Get<BlockNumberFor<Self>>;
+
         #[pallet::no_default_bounds]
         type RuntimeEvent: From<Event<Self>>
             + IsType<<Self as polkadot_sdk::frame_system::Config>::RuntimeEvent>;
@@ -329,6 +342,18 @@ pub mod pallet {
                 weight_control_fee,
             )
         }
+
+        /// Updates origin's key agent metadata.
+        #[pallet::call_index(6)]
+        #[pallet::weight((Weight::zero(), DispatchClass::Normal, Pays::Yes))]
+        pub fn set_agent_update_cooldown(
+            origin: OriginFor<T>,
+            new_cooldown: BlockNumberFor<T>,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            AgentUpdateCooldown::<T>::set(new_cooldown);
+            Ok(())
+        }
     }
 
     #[pallet::event]
@@ -428,6 +453,8 @@ pub mod pallet {
         InvalidStakingFee,
         /// The weight control fee given is lower than the minimum fee
         InvalidWeightControlFee,
+        /// The agent already updated recently
+        AgentUpdateOnCooldown,
     }
 }
 
@@ -516,6 +543,7 @@ impl<T: Config>
                 weight_penalty_factor: Default::default(),
                 registration_block: Default::default(),
                 fees: Default::default(),
+                last_update_block: Default::default(),
             }),
         );
 

pallets/torus0/src/migrations.rs

@@ -4,17 +4,60 @@ use polkadot_sdk::frame_support::{
 
 use crate::{Config, Pallet};
 
-pub mod v2 {
+pub mod v3 {
     use super::*;
     use crate::{Agent, Agents};
-    pub type Migration<T, W> = VersionedMigration<1, 2, MigrateToV1<T>, Pallet<T>, W>;
-    pub struct MigrateToV1<T>(core::marker::PhantomData<T>);
-    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV1<T> {
+    use scale_info::prelude::vec::Vec;
+
+    pub mod storage {
+        use codec::{Decode, Encode, MaxEncodedLen};
+        use polkadot_sdk::frame_support::{storage_alias, DebugNoBound, Identity};
+        use polkadot_sdk::polkadot_sdk_frame::prelude::BlockNumberFor;
+        use polkadot_sdk::sp_runtime::{BoundedVec, Percent};
+        use scale_info::TypeInfo;
+
+        use crate::AccountIdOf;
+
+        #[derive(DebugNoBound, Encode, Decode, MaxEncodedLen, TypeInfo)]
+        #[scale_info(skip_type_params(T))]
+        pub struct Agent<T: crate::Config> {
+            pub key: AccountIdOf<T>,
+            pub name: BoundedVec<u8, T::MaxAgentNameLengthConstraint>,
+            pub url: BoundedVec<u8, T::MaxAgentUrlLengthConstraint>,
+            pub metadata: BoundedVec<u8, T::MaxAgentMetadataLengthConstraint>,
+            pub weight_penalty_factor: Percent,
+            pub registration_block: BlockNumberFor<T>,
+            pub fees: crate::fee::ValidatorFee<T>,
+        }
+
+        #[storage_alias]
+        pub type Agents<T: crate::Config> =
+            StorageMap<crate::Pallet<T>, Identity, AccountIdOf<T>, Agent<T>>;
+    }
+
+    pub type Migration<T, W> = VersionedMigration<2, 3, MigrateToV3<T>, Pallet<T>, W>;
+    pub struct MigrateToV3<T>(core::marker::PhantomData<T>);
+    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV3<T> {
         fn on_runtime_upgrade() -> Weight {
-            Agents::<T>::translate(|_key, mut agent: Agent<T>| {
-                agent.fees = Default::default();
-                Some(agent)
-            });
+            let old_agents = storage::Agents::<T>::iter().collect::<Vec<_>>();
+            let _ = storage::Agents::<T>::clear(u32::MAX, None);
+
+            for (id, old_agent) in old_agents {
+                Agents::<T>::insert(
+                    id,
+                    Agent {
+                        key: old_agent.key,
+                        name: old_agent.name,
+                        url: old_agent.url,
+                        metadata: old_agent.metadata,
+                        registration_block: old_agent.registration_block,
+                        weight_penalty_factor: old_agent.weight_penalty_factor,
+                        fees: old_agent.fees,
+                        last_update_block: old_agent.registration_block,
+                    },
+                )
+            }
+
             Weight::zero()
         }
     }