feat(permission0): bulk namespace creation (#136)

Adding an extrinsic allowing creation of multiple namespace permissions
in a single call. This is rather useful for big agents during swarm
creation.

Author: saiintbrisson

pallets/faucet/tests/faucet.rs

@@ -263,6 +263,7 @@ impl pallet_permission0::Config for Test {
     type MaxNamespacesPerPermission = ConstU32<0>;
     type MaxChildrenPerPermission = ConstU32<0>;
     type MaxCuratorSubpermissionsPerPermission = ConstU32<0>;
+    type MaxBulkOperationsPerCall = ConstU32<20>;
 }
 
 impl pallet_balances::Config for Test {

pallets/permission0/src/lib.rs

@@ -87,6 +87,10 @@ pub mod pallet {
         /// Maximum number of children a single permission can have.
         #[pallet::constant]
         type MaxChildrenPerPermission: Get<u32>;
+
+        /// Max operations a bulk extrinsic can perform per extrinsic call.
+        #[pallet::constant]
+        type MaxBulkOperationsPerCall: Get<u32>;
     }
 
     pub type BalanceOf<T> =
@@ -487,6 +491,40 @@ pub mod pallet {
             Ok(())
         }
 
+        /// Delegate a permission over namespaces to multiple recipients.
+        /// Note: this extrinsic creates _multiple_ permissions with the same
+        /// properties.
+        #[pallet::call_index(10)]
+        #[pallet::weight({
+            T::WeightInfo::delegate_namespace_permission()
+                .saturating_mul(recipients.len() as u64)
+        })]
+        pub fn bulk_delegate_namespace_permission(
+            origin: OriginFor<T>,
+            recipients: BoundedBTreeSet<T::AccountId, T::MaxBulkOperationsPerCall>,
+            paths: BoundedBTreeMap<
+                Option<PermissionId>,
+                BoundedBTreeSet<NamespacePathInner, T::MaxNamespacesPerPermission>,
+                T::MaxNamespacesPerPermission,
+            >,
+            duration: PermissionDuration<T>,
+            revocation: RevocationTerms<T>,
+            instances: u32,
+        ) -> DispatchResult {
+            for recipient in recipients {
+                ext::namespace_impl::delegate_namespace_permission_impl::<T>(
+                    origin.clone(),
+                    recipient,
+                    paths.clone(),
+                    duration.clone(),
+                    revocation.clone(),
+                    instances,
+                )?;
+            }
+
+            Ok(())
+        }
+
         /// Allows Delegator/Recipient to edit stream permission
         #[pallet::call_index(8)]
         #[pallet::weight(T::WeightInfo::delegate_curator_permission())]

pallets/permission0/tests/namespace.rs

@@ -1903,3 +1903,151 @@ fn update_namespace_permission_smaller_instances() {
         assert_eq!(updated.max_instances, 5);
     });
 }
+
+#[test]
+fn bulk_delegate_namespace_permission_fails_when_redelegation_exceeds_parent_instances() {
+    new_test_ext().execute_with(|| {
+        zero_min_burn();
+        let alice = 0;
+        let bob = 1;
+        let charlie = 2;
+        let dave = 3;
+
+        register_agent(alice);
+        register_agent(bob);
+        register_agent(charlie);
+        register_agent(dave);
+
+        // Alice creates a namespace and delegates to Bob with 3 instances
+        let namespace = register_namespace(alice, b"agent.alice.compute");
+        let alice_paths = paths_map!(None => [namespace.clone()]);
+
+        assert_ok!(Permission0::delegate_namespace_permission(
+            get_origin(alice),
+            bob,
+            alice_paths,
+            PermissionDuration::Indefinite,
+            RevocationTerms::Irrevocable,
+            3 // Bob gets 3 instances
+        ));
+
+        let bob_permission_id = get_last_delegated_permission_id(alice);
+
+        // Bob tries to redelegate to Charlie and Dave with 2 instances each (total 4)
+        // This should fail because Bob only has 3 instances available
+        let bob_paths = paths_map!(Some(bob_permission_id) => [namespace]);
+
+        let mut recipients = BoundedBTreeSet::new();
+        recipients.try_insert(charlie).unwrap();
+        recipients.try_insert(dave).unwrap();
+
+        // This should fail because 2 recipients × 2 instances = 4 instances needed,
+        // but Bob only has 3 instances available
+        assert_err!(
+            Permission0::bulk_delegate_namespace_permission(
+                get_origin(bob),
+                recipients,
+                bob_paths,
+                PermissionDuration::Indefinite,
+                RevocationTerms::Irrevocable,
+                2 // 2 instances per recipient
+            ),
+            Error::<Test>::NotEnoughInstances
+        );
+
+        // Verify no permissions were created
+        assert_eq!(
+            PermissionsByRecipient::<Test>::get(charlie).len(),
+            0,
+            "Charlie should have no permissions"
+        );
+        assert_eq!(
+            PermissionsByRecipient::<Test>::get(dave).len(),
+            0,
+            "Dave should have no permissions"
+        );
+
+        // Verify Bob's permission still has all instances available
+        let bob_permission = Permissions::<Test>::get(bob_permission_id).unwrap();
+        assert_eq!(bob_permission.available_instances(), 3);
+        assert_eq!(bob_permission.children.len(), 0);
+    });
+}
+
+#[test]
+fn bulk_delegate_namespace_permission_succeeds_within_parent_instance_limit() {
+    new_test_ext().execute_with(|| {
+        zero_min_burn();
+        let alice = 0;
+        let bob = 1;
+        let charlie = 2;
+        let dave = 3;
+
+        register_agent(alice);
+        register_agent(bob);
+        register_agent(charlie);
+        register_agent(dave);
+
+        // Alice creates a namespace and delegates to Bob with 4 instances
+        let namespace = register_namespace(alice, b"agent.alice.compute");
+        let alice_paths = paths_map!(None => [namespace.clone()]);
+
+        assert_ok!(Permission0::delegate_namespace_permission(
+            get_origin(alice),
+            bob,
+            alice_paths,
+            PermissionDuration::Indefinite,
+            RevocationTerms::Irrevocable,
+            4 // Bob gets 4 instances
+        ));
+
+        let bob_permission_id = get_last_delegated_permission_id(alice);
+
+        // Bob redelegates to Charlie and Dave with 2 instances each (total 4)
+        // This should succeed because Bob has exactly 4 instances available
+        let bob_paths = paths_map!(Some(bob_permission_id) => [namespace]);
+
+        let mut recipients = BoundedBTreeSet::new();
+        recipients.try_insert(charlie).unwrap();
+        recipients.try_insert(dave).unwrap();
+
+        assert_ok!(Permission0::bulk_delegate_namespace_permission(
+            get_origin(bob),
+            recipients,
+            bob_paths,
+            PermissionDuration::Indefinite,
+            RevocationTerms::Irrevocable,
+            2 // 2 instances per recipient
+        ));
+
+        // Verify permissions were created
+        assert_eq!(
+            PermissionsByRecipient::<Test>::get(charlie).len(),
+            1,
+            "Charlie should have 1 permission"
+        );
+        assert_eq!(
+            PermissionsByRecipient::<Test>::get(dave).len(),
+            1,
+            "Dave should have 1 permission"
+        );
+
+        // Get the created permission IDs using helper function
+        let charlie_permission_id = get_permission_id_for_recipient(charlie);
+        let dave_permission_id = get_permission_id_for_recipient(dave);
+
+        // Verify each permission has 2 instances
+        let charlie_permission = Permissions::<Test>::get(charlie_permission_id).unwrap();
+        assert_eq!(charlie_permission.max_instances, 2);
+
+        let dave_permission = Permissions::<Test>::get(dave_permission_id).unwrap();
+        assert_eq!(dave_permission.max_instances, 2);
+
+        // Verify Bob's permission has no instances left available
+        let bob_permission = Permissions::<Test>::get(bob_permission_id).unwrap();
+        assert_eq!(bob_permission.available_instances(), 0); // 4 - (2+2) = 0
+        assert_eq!(bob_permission.children.len(), 2);
+        assert!(bob_permission.children.contains(&charlie_permission_id));
+        assert!(bob_permission.children.contains(&dave_permission_id));
+    });
+}

runtime/src/configs.rs

@@ -471,6 +471,7 @@ parameter_types! {
     pub const MaxNamespacesPerPermission: u32 = 16;
     pub const MaxChildrenPerPermission: u32 = 16;
     pub const MaxCuratorSubpermissionsPerPermission: u32 = 16;
+    pub const MaxBulkOperationsPerCall: u32 = 20;
 }
 
 impl pallet_permission0::Config for Runtime {
@@ -494,6 +495,7 @@ impl pallet_permission0::Config for Runtime {
     type MaxNamespacesPerPermission = MaxNamespacesPerPermission;
     type MaxChildrenPerPermission = MaxChildrenPerPermission;
     type MaxCuratorSubpermissionsPerPermission = MaxCuratorSubpermissionsPerPermission;
+    type MaxBulkOperationsPerCall = MaxBulkOperationsPerCall;
 }
 
 impl pallet_faucet::Config for Runtime {

test-utils/src/lib.rs

@@ -270,6 +270,7 @@ impl pallet_permission0::Config for Test {
     type MaxNamespacesPerPermission = ConstU32<10>;
     type MaxChildrenPerPermission = ConstU32<10>;
     type MaxCuratorSubpermissionsPerPermission = ConstU32<10>;
+    type MaxBulkOperationsPerCall = ConstU32<20>;
 }
 
 impl pallet_balances::Config for Test {