feat: add stream emission permission editing (#104)

Closes CHAIN-95

---------

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

Author: devwckd

pallets/permission0/src/ext/emission_impl.rs

@@ -1,6 +1,9 @@
 use crate::{
+    generate_permission_id, get_total_allocated_percentage, pallet,
     permission::{emission::*, *},
-    *,
+    update_permission_indices, AccumulatedStreamAmounts, BalanceOf, Config, DistributionControl,
+    EmissionAllocation, EmissionScope, EnforcementTracking, Error, Event, NegativeImbalanceOf,
+    Pallet, PermissionContract, PermissionDuration, PermissionId, PermissionScope, Permissions,
 };
 
 use pallet_permission0_api::{
@@ -10,7 +13,7 @@ use pallet_permission0_api::{
 };
 use polkadot_sdk::{
     frame_support::{dispatch::DispatchResult, ensure, traits::ReservableCurrency},
-    frame_system::{self, ensure_signed_or_root},
+    frame_system::{self, ensure_signed, ensure_signed_or_root},
     polkadot_sdk_frame::prelude::{BlockNumberFor, OriginFor},
     sp_core::{Get, TryCollect},
     sp_runtime::{
@@ -129,32 +132,12 @@ pub(crate) fn grant_emission_permission_impl<T: Config>(
         Error::<T>::NotRegisteredAgent
     );
     ensure!(grantor != grantee, Error::<T>::SelfPermissionNotAllowed);
-    ensure!(!targets.is_empty(), Error::<T>::NoTargetsSpecified);
 
-    for (target, weight) in &targets {
-        ensure!(*weight > 0, Error::<T>::InvalidTargetWeight);
-        ensure!(
-            T::Torus::is_agent_registered(target),
-            Error::<T>::NotRegisteredAgent
-        );
-    }
+    validate_emission_permission_target_weights::<T>(&targets)?;
 
     match &allocation {
         EmissionAllocation::Streams(streams) => {
-            for (stream, percentage) in streams {
-                ensure!(*percentage <= Percent::one(), Error::<T>::InvalidPercentage);
-
-                let total_allocated = get_total_allocated_percentage::<T>(&grantor, stream);
-                let new_total_allocated = match total_allocated.checked_add(percentage) {
-                    Some(new_total_allocated) => new_total_allocated,
-                    None => return Err(Error::<T>::TotalAllocationExceeded.into()),
-                };
-
-                ensure!(
-                    new_total_allocated <= Percent::one(),
-                    Error::<T>::TotalAllocationExceeded
-                );
-            }
+            validate_emission_permission_streams::<T>(streams, &grantor)?;
         }
         EmissionAllocation::FixedAmount(amount) => {
             ensure!(*amount > BalanceOf::<T>::zero(), Error::<T>::InvalidAmount);
@@ -172,22 +155,7 @@ pub(crate) fn grant_emission_permission_impl<T: Config>(
         }
     }
 
-    match &distribution {
-        DistributionControl::Automatic(threshold) => {
-            ensure!(
-                *threshold >= T::MinAutoDistributionThreshold::get(),
-                Error::<T>::InvalidThreshold
-            );
-        }
-        DistributionControl::Interval(interval) => {
-            ensure!(!interval.is_zero(), Error::<T>::InvalidInterval);
-        }
-        DistributionControl::AtBlock(block) => {
-            let current_block = <polkadot_sdk::frame_system::Pallet<T>>::block_number();
-            ensure!(*block > current_block, Error::<T>::InvalidInterval);
-        }
-        _ => {}
-    }
+    validate_emission_permission_distribution::<T>(&distribution)?;
 
     if let Some(parent) = parent_id {
         let parent_contract =
@@ -362,3 +330,136 @@ pub fn toggle_permission_accumulation_impl<T: Config>(
 
     Ok(())
 }
+
+pub(crate) fn update_emission_permission<T: Config>(
+    origin: OriginFor<T>,
+    permission_id: PermissionId,
+    new_targets: BoundedBTreeMap<T::AccountId, u16, T::MaxTargetsPerPermission>,
+    new_streams: Option<BoundedBTreeMap<StreamId, Percent, T::MaxStreamsPerPermission>>,
+    new_distribution_control: Option<DistributionControl<T>>,
+) -> DispatchResult {
+    let who = ensure_signed(origin)?;
+
+    let permission = Permissions::<T>::get(permission_id);
+
+    let Some(mut permission) = permission else {
+        return Err(Error::<T>::PermissionNotFound.into());
+    };
+
+    if permission.grantor == who {
+        if !permission.is_updatable() {
+            return Err(Error::<T>::NotEditable.into());
+        }
+    } else if permission.grantee == who {
+        if new_streams.is_some() || new_distribution_control.is_some() {
+            return Err(Error::<T>::NotAuthorizedToEdit.into());
+        }
+    } else {
+        return Err(Error::<T>::NotAuthorizedToEdit.into());
+    }
+
+    let mut scope = permission.scope.clone();
+    match &mut scope {
+        PermissionScope::Emission(emission_scope) => {
+            validate_emission_permission_target_weights::<T>(&new_targets)?;
+
+            emission_scope.targets = new_targets;
+
+            let EmissionAllocation::Streams(streams) = &mut emission_scope.allocation else {
+                return Err(Error::<T>::NotEditable.into());
+            };
+
+            if let Some(new_streams) = new_streams {
+                crate::permission::emission::do_distribute_emission::<T>(
+                    permission_id,
+                    &permission,
+                    DistributionReason::Manual,
+                );
+
+                for stream in streams.keys() {
+                    AccumulatedStreamAmounts::<T>::remove((
+                        &permission.grantor,
+                        stream,
+                        &permission_id,
+                    ));
+                }
+
+                validate_emission_permission_streams::<T>(&new_streams, &permission.grantor)?;
+
+                *streams = new_streams;
+            }
+
+            if let Some(new_distribution_control) = new_distribution_control {
+                validate_emission_permission_distribution::<T>(&new_distribution_control)?;
+
+                emission_scope.distribution = new_distribution_control;
+            }
+        }
+        _ => return Err(Error::<T>::NotEditable.into()),
+    }
+
+    permission.scope = scope;
+    Permissions::<T>::set(permission_id, Some(permission));
+
+    Ok(())
+}
+
+fn validate_emission_permission_target_weights<T: Config>(
+    targets: &BoundedBTreeMap<T::AccountId, u16, T::MaxTargetsPerPermission>,
+) -> DispatchResult {
+    ensure!(!targets.is_empty(), Error::<T>::NoTargetsSpecified);
+
+    for (target, weight) in targets {
+        ensure!(*weight > 0, Error::<T>::InvalidTargetWeight);
+        ensure!(
+            T::Torus::is_agent_registered(target),
+            Error::<T>::NotRegisteredAgent
+        );
+    }
+
+    Ok(())
+}
+fn validate_emission_permission_streams<T: Config>(
+    streams: &BoundedBTreeMap<StreamId, Percent, T::MaxStreamsPerPermission>,
+    grantor: &T::AccountId,
+) -> DispatchResult {
+    for (stream, percentage) in streams {
+        ensure!(*percentage <= Percent::one(), Error::<T>::InvalidPercentage);
+
+        let total_allocated = get_total_allocated_percentage::<T>(grantor, stream);
+        let new_total_allocated = match total_allocated.checked_add(percentage) {
+            Some(new_total_allocated) => new_total_allocated,
+            None => return Err(Error::<T>::TotalAllocationExceeded.into()),
+        };
+
+        ensure!(
+            new_total_allocated <= Percent::one(),
+            Error::<T>::TotalAllocationExceeded
+        );
+    }
+
+    Ok(())
+}
+
+fn validate_emission_permission_distribution<T: Config>(
+    distribution: &DistributionControl<T>,
+) -> DispatchResult {
+    match distribution {
+        DistributionControl::Automatic(threshold) => {
+            ensure!(
+                *threshold >= T::MinAutoDistributionThreshold::get(),
+                Error::<T>::InvalidThreshold
+            );
+        }
+        DistributionControl::Interval(interval) => {
+            ensure!(!interval.is_zero(), Error::<T>::InvalidInterval);
+        }
+        DistributionControl::AtBlock(block) => {
+            let current_block = <polkadot_sdk::frame_system::Pallet<T>>::block_number();
+            ensure!(*block > current_block, Error::<T>::InvalidInterval);
+        }
+        _ => {}
+    }
+
+    Ok(())
+}

pallets/permission0/src/lib.rs

@@ -300,6 +300,10 @@ pub mod pallet {
         NamespacePathIsInvalid,
         /// Exceeded amount of total namespaces allowed in a single permission.
         TooManyNamespaces,
+        /// Not authorized to edit a stream emission permission.
+        NotAuthorizedToEdit,
+        /// Stream emission permission is not editable
+        NotEditable,
     }
 
     #[pallet::hooks]
@@ -448,6 +452,27 @@ pub mod pallet {
 
             Ok(())
         }
+
+        /// Allows Grantor/Grantee to edit stream emission permission
+        #[pallet::call_index(8)]
+        #[pallet::weight(T::WeightInfo::grant_curator_permission())]
+        pub fn update_emission_permission(
+            origin: OriginFor<T>,
+            permission_id: PermissionId,
+            new_targets: BoundedBTreeMap<T::AccountId, u16, T::MaxTargetsPerPermission>,
+            new_streams: Option<BoundedBTreeMap<StreamId, Percent, T::MaxStreamsPerPermission>>,
+            new_distribution_control: Option<DistributionControl<T>>,
+        ) -> DispatchResult {
+            ext::emission_impl::update_emission_permission(
+                origin,
+                permission_id,
+                new_targets,
+                new_streams,
+                new_distribution_control,
+            )?;
+
+            Ok(())
+        }
     }
 }
 

pallets/permission0/src/permission.rs

@@ -219,6 +219,16 @@ impl<T: Config> PermissionContract<T> {
             }
         }
     }
+
+    pub fn is_updatable(&self) -> bool {
+        let current_block = frame_system::Pallet::<T>::block_number();
+
+        match &self.revocation {
+            RevocationTerms::RevocableByGrantor => true,
+            RevocationTerms::RevocableAfter(block) => &current_block > block,
+            _ => false,
+        }
+    }
 }
 
 /// Defines what the permission applies to