fix(permission0): allow grantor to delegate emission to itself (#107)

After discussing how the emissions will be initially used, it was clear
to us that there are no cases where it makes sense to delegate emissions
permission to another agent. In this case, the best way to delegate is
to itself, which allows the agent to control how the emissions will flow
and edit the targets at will.

Author: saiintbrisson

justfile

@@ -1,4 +1,4 @@
-default: check test
+default: fmt check test
 
 # Build
 
@@ -11,11 +11,14 @@ build-testnet:
 # Development
 
 check:
-  cargo clippy
+  cargo clippy --tests
 
 test:
   cargo test
 
+fmt:
+  cargo fmt
+
 run-localnode profile="--alice":
   cargo xtask run local {{profile}}
 

pallets/permission0/src/ext/emission_impl.rs

@@ -131,7 +131,6 @@ pub(crate) fn grant_emission_permission_impl<T: Config>(
         T::Torus::is_agent_registered(&grantee),
         Error::<T>::NotRegisteredAgent
     );
-    ensure!(grantor != grantee, Error::<T>::SelfPermissionNotAllowed);
 
     validate_emission_permission_target_weights::<T>(&targets)?;
 
@@ -346,15 +345,11 @@ pub(crate) fn update_emission_permission<T: Config>(
         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 {
+    let allowed_grantor = permission.grantor == who && permission.is_updatable();
+    let allowed_grantee =
+        permission.grantee == who && (new_streams.is_none() && new_distribution_control.is_none());
+
+    if !allowed_grantor && !allowed_grantee {
         return Err(Error::<T>::NotAuthorizedToEdit.into());
     }
 
@@ -386,6 +381,13 @@ pub(crate) fn update_emission_permission<T: Config>(
 
                 validate_emission_permission_streams::<T>(&new_streams, &permission.grantor)?;
 
+                for stream in new_streams.keys() {
+                    AccumulatedStreamAmounts::<T>::set(
+                        (&permission.grantor, stream, permission_id),
+                        Some(Zero::zero()),
+                    )
+                }
+
                 *streams = new_streams;
             }
 

pallets/permission0/tests/stream.rs

@@ -338,7 +338,7 @@ fn grantor_cannot_change_irrevocable_permission() {
                 None,
                 None
             ),
-            pallet_permission0::Error::<Test>::NotEditable
+            pallet_permission0::Error::<Test>::NotAuthorizedToEdit
         );
     });
 }
@@ -401,7 +401,7 @@ fn grantor_cannot_change_arbiter_permission() {
                 None,
                 None
             ),
-            pallet_permission0::Error::<Test>::NotEditable
+            pallet_permission0::Error::<Test>::NotAuthorizedToEdit
         );
     });
 }
@@ -461,7 +461,7 @@ fn grantor_cannot_change_permission_before_block() {
                 None,
                 None
             ),
-            pallet_permission0::Error::<Test>::NotEditable
+            pallet_permission0::Error::<Test>::NotAuthorizedToEdit
         );
 
         step_block(6);
@@ -575,10 +575,9 @@ fn updating_works() {
 
         add_balance(agent_0, as_tors(10) + 1);
 
-        let stream_id = generate_root_stream_id(&agent_0);
-
+        let stream = generate_root_stream_id(&agent_0);
         let mut streams = BTreeMap::new();
-        streams.insert(stream_id, Percent::from_percent(100));
+        streams.insert(stream, Percent::from_percent(100));
 
         let permission_id = assert_ok!(grant_emission_permission(
             agent_0,
@@ -597,19 +596,23 @@ fn updating_works() {
 
         assert!(AccumulatedStreamAmounts::<Test>::contains_key((
             &agent_0,
-            &stream_id,
+            &stream,
             &permission_id
         )));
 
         let mut new_targets = BoundedBTreeMap::new();
-        new_targets.try_insert(agent_0, u16::MAX).unwrap();
+        new_targets.try_insert(agent_1, u16::MAX).unwrap();
+
+        let new_stream = generate_root_stream_id(&agent_1);
+        let mut new_streams = BTreeMap::new();
+        new_streams.insert(new_stream, Percent::from_percent(100));
 
         assert_ok!(
             pallet_permission0::Pallet::<Test>::update_emission_permission(
                 get_origin(agent_0),
                 permission_id,
                 new_targets.clone(),
-                Some(streams.clone().try_into().unwrap()),
+                Some(new_streams.clone().try_into().unwrap()),
                 Some(pallet_permission0::DistributionControl::Interval(100))
             )
         );
@@ -624,9 +627,21 @@ fn updating_works() {
 
         assert_eq!(
             emission_scope.allocation,
-            pallet_permission0::EmissionAllocation::Streams(streams.try_into().unwrap())
+            pallet_permission0::EmissionAllocation::Streams(new_streams.try_into().unwrap())
         );
 
+        assert!(!AccumulatedStreamAmounts::<Test>::contains_key((
+            &agent_0,
+            &stream,
+            &permission_id
+        )));
+
+        assert!(AccumulatedStreamAmounts::<Test>::contains_key((
+            &agent_0,
+            new_stream,
+            &permission_id,
+        )));
+
         assert_eq!(
             emission_scope.distribution,
             pallet_permission0::DistributionControl::Interval(100)
@@ -635,3 +650,74 @@ fn updating_works() {
         assert_eq!(emission_scope.targets, new_targets);
     });
 }
+
+#[test]
+fn update_prevents_overarching_update_when_grantor_is_grantee() {
+    test_utils::new_test_ext().execute_with(|| {
+        zero_min_burn();
+        let agent_0 = 0;
+        register_empty_agent(agent_0);
+
+        let agent_1 = 1;
+        register_empty_agent(agent_1);
+
+        let agent_2 = 1;
+        register_empty_agent(agent_2);
+
+        let agent_3 = 1;
+        register_empty_agent(agent_3);
+
+        add_balance(agent_0, as_tors(10) + 1);
+
+        let stream_id = generate_root_stream_id(&agent_0);
+        let mut streams = BTreeMap::new();
+        streams.insert(stream_id, Percent::from_percent(100));
+
+        let permission_id = assert_ok!(grant_emission_permission(
+            agent_0,
+            agent_0,
+            pallet_permission0_api::EmissionAllocation::Streams(streams.clone()),
+            vec![(agent_1, u16::MAX)],
+            pallet_permission0_api::DistributionControl::Manual,
+            pallet_permission0_api::PermissionDuration::Indefinite,
+            pallet_permission0_api::RevocationTerms::RevocableAfter(5),
+            pallet_permission0_api::EnforcementAuthority::None,
+        ));
+
+        let mut new_targets = BoundedBTreeMap::new();
+        new_targets.try_insert(agent_1, u16::MAX).unwrap();
+
+        assert_err!(
+            pallet_permission0::Pallet::<Test>::update_emission_permission(
+                get_origin(agent_0),
+                permission_id,
+                new_targets.clone(),
+                Some(BoundedBTreeMap::new()),
+                None
+            ),
+            pallet_permission0::Error::<Test>::NotAuthorizedToEdit
+        );
+
+        assert_ok!(
+            pallet_permission0::Pallet::<Test>::update_emission_permission(
+                get_origin(agent_0),
+                permission_id,
+                new_targets.clone(),
+                None,
+                None
+            )
+        );
+
+        step_block(6);
+
+        assert_ok!(
+            pallet_permission0::Pallet::<Test>::update_emission_permission(
+                get_origin(agent_0),
+                permission_id,
+                new_targets.clone(),
+                Some(streams.clone().try_into().unwrap()),
+                Some(pallet_permission0::DistributionControl::Interval(100))
+            )
+        );
+    });
+}

runtime/src/lib.rs

@@ -38,7 +38,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     spec_name: create_runtime_str!("torus-runtime"),
     impl_name: create_runtime_str!("torus-runtime"),
     authoring_version: 1,
-    spec_version: 19,
+    spec_version: 20,
     impl_version: 1,
     apis: apis::RUNTIME_API_VERSIONS,
     transaction_version: 1,