feat(permission0): stream funnels

Author: saiintbrisson

.helix/languages.toml

@@ -2,4 +2,4 @@
 cargo.extraEnv = { SKIP_WASM_BUILD = "true" }
 cargo.features = ["runtime-benchmarks"]
 check.extraEnv = { SKIP_WASM_BUILD = "true" }
-check.overrideCommand = ["cargo", "check", "--message-format=json"]
+check.overrideCommand = ["cargo", "check", "--tests", "--all", "--message-format=json"]

pallets/faucet/tests/faucet.rs

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

pallets/permission0/api/src/lib.rs

@@ -26,6 +26,17 @@ pub fn generate_root_stream_id<AccountId: Encode>(agent_id: &AccountId) -> Strea
     blake2_256(&data).into()
 }
 
+/// Static identifier for funneled streams
+pub const FUNNEL_STREAM_PREFIX: &[u8] = b"torus:permission:funnel-v1";
+
+/// Generates a funneled stream ID.
+pub fn generate_funnel_stream_id(permission_id: &PermissionId, nonce: u32) -> StreamId {
+    let mut data = FUNNEL_STREAM_PREFIX.to_vec();
+    data.extend(permission_id.encode());
+    data.extend(nonce.encode());
+    blake2_256(&data).into()
+}
+
 /// Defines what portion of streams the permission applies to
 #[derive(Encode, Decode, TypeInfo, Clone, PartialEq, Eq, Debug)]
 pub enum StreamAllocation<Balance> {
@@ -113,6 +124,7 @@ pub trait Permission0StreamApi<AccountId, Origin, BlockNumber, Balance, Negative
         enforcement: EnforcementAuthority<AccountId>,
         recipient_manager: Option<AccountId>,
         weight_setter: Option<AccountId>,
+        enable_funnel: bool,
     ) -> Result<PermissionId, DispatchError>;
 
     /// Accumulate streams for an agent with permissions

pallets/permission0/src/ext/stream_impl.rs

@@ -43,6 +43,7 @@ impl<T: Config>
         enforcement: ApiEnforcementAuthority<T::AccountId>,
         recipient_manager: Option<T::AccountId>,
         weight_setter: Option<T::AccountId>,
+        enable_funnel: bool,
     ) -> Result<PermissionId, DispatchError> {
         let internal_allocation = match allocation {
             ApiStreamAllocation::Streams(streams) => StreamAllocation::Streams(
@@ -81,6 +82,7 @@ impl<T: Config>
             enforcement,
             recipient_manager,
             weight_setter,
+            enable_funnel,
         )
     }
 
@@ -121,6 +123,7 @@ pub(crate) fn delegate_stream_permission_impl<T: Config>(
     enforcement: EnforcementAuthority<T>,
     recipient_manager: Option<T::AccountId>,
     weight_setter: Option<T::AccountId>,
+    enable_funnel: bool,
 ) -> Result<PermissionId, DispatchError> {
     use polkadot_sdk::frame_support::ensure;
 
@@ -155,17 +158,22 @@ pub(crate) fn delegate_stream_permission_impl<T: Config>(
 
     let recipients_ids: Vec<_> = recipients.keys().cloned().collect();
 
-    let scope = PermissionScope::Stream(StreamScope {
+    let mut scope = PermissionScope::Stream(StreamScope {
         recipients,
         allocation: allocation.clone(),
         distribution,
-        accumulating: true, // Start with accumulation enabled by default
+        accumulating: true,
         recipient_managers: validate_stream_managers::<T>(&delegator, recipient_manager)?,
         weight_setters: validate_stream_managers::<T>(&delegator, weight_setter)?,
+        funnels: Default::default(),
     });
 
     let permission_id = generate_permission_id::<T>(&delegator, &scope)?;
 
+    if enable_funnel && let PermissionScope::Stream(stream) = &mut scope {
+        stream.enable_funnel(permission_id)?;
+    }
+
     let contract =
         PermissionContract::<T>::new(delegator.clone(), scope, duration, revocation, enforcement);
 
@@ -316,6 +324,7 @@ pub(crate) fn update_stream_permission<T: Config>(
     new_distribution_control: Option<DistributionControl<T>>,
     new_recipient_manager: Option<Option<T::AccountId>>,
     new_weight_setter: Option<Option<T::AccountId>>,
+    funnel: Option<bool>,
 ) -> DispatchResult {
     let caller = ensure_signed(origin)?;
 
@@ -421,6 +430,16 @@ pub(crate) fn update_stream_permission<T: Config>(
             validate_stream_managers::<T>(&permission.delegator, new_weight_setter)?;
     }
 
+    if let Some(funnel) = funnel {
+        ensure!(allowed_delegator, Error::<T>::NotAuthorizedToEdit);
+
+        if funnel {
+            let _ = scope.enable_funnel(permission_id);
+        } else {
+            let _ = scope.disable_funnel();
+        }
+    }
+
     permission.scope = PermissionScope::Stream(scope);
     permission.last_update = frame_system::Pallet::<T>::block_number();
     Permissions::<T>::set(permission_id, Some(permission));

pallets/permission0/src/lib.rs

@@ -39,7 +39,7 @@ pub mod pallet {
 
     use super::*;
 
-    const STORAGE_VERSION: StorageVersion = StorageVersion::new(7);
+    const STORAGE_VERSION: StorageVersion = StorageVersion::new(8);
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
@@ -92,6 +92,10 @@ pub mod pallet {
         /// Max operations a bulk extrinsic can perform per extrinsic call.
         #[pallet::constant]
         type MaxBulkOperationsPerCall: Get<u32>;
+
+        /// Max number of funnels per stream permission.
+        #[pallet::constant]
+        type MaxFunnelsPerPermission: Get<u32>;
     }
 
     pub type BalanceOf<T> =
@@ -220,7 +224,11 @@ pub mod pallet {
         /// An stream distribution happened
         StreamDistribution {
             permission_id: PermissionId,
-            stream_id: Option<StreamId>,
+            /// The source stream ID from which the tokens were derived.
+            source_stream: Option<StreamId>,
+            /// The actual final stream ID to which tokens were accumulated,
+            /// this is the funnel stream ID if enabled.
+            target_stream: Option<StreamId>,
             recipient: T::AccountId,
             amount: BalanceOf<T>,
             reason: permission::stream::DistributionReason,
@@ -329,6 +337,8 @@ pub mod pallet {
         TooManyCuratorPermissions,
         /// Namespace delegation depth exceeded the maximum allowed limit.
         DelegationDepthExceeded,
+        /// Current funnel system is limited to one derived stream per permission.
+        TooManyStreamFunnels,
     }
 
     #[pallet::hooks]
@@ -353,6 +363,7 @@ pub mod pallet {
             enforcement: EnforcementAuthority<T>,
             recipient_manager: Option<T::AccountId>,
             weight_setter: Option<T::AccountId>,
+            enable_funnel: bool,
         ) -> DispatchResult {
             let delegator = ensure_signed(origin)?;
 
@@ -366,6 +377,7 @@ pub mod pallet {
                 enforcement,
                 recipient_manager,
                 weight_setter,
+                enable_funnel,
             )?;
 
             Ok(())
@@ -560,6 +572,7 @@ pub mod pallet {
             new_distribution_control: Option<DistributionControl<T>>,
             new_recipient_manager: Option<Option<T::AccountId>>,
             new_weight_setter: Option<Option<T::AccountId>>,
+            funnel: Option<bool>,
         ) -> DispatchResult {
             ext::stream_impl::update_stream_permission(
                 origin,
@@ -569,6 +582,7 @@ pub mod pallet {
                 new_distribution_control,
                 new_recipient_manager,
                 new_weight_setter,
+                funnel,
             )?;
 
             Ok(())

pallets/permission0/src/migrations.rs

@@ -1 +1,103 @@
+use polkadot_sdk::frame_support::{
+    migrations::VersionedMigration, pallet_prelude::*, traits::UncheckedOnRuntimeUpgrade,
+};
 
+use crate::{Config, PermissionId, Permissions};
+
+pub mod v8 {
+
+    use super::*;
+
+    pub type MigrationToV8<T, W> = VersionedMigration<7, 8, MigrateToV8<T>, crate::Pallet<T>, W>;
+
+    pub struct MigrateToV8<T>(core::marker::PhantomData<T>);
+
+    mod old {
+        use codec::{Decode, Encode};
+        use polkadot_sdk::{
+            polkadot_sdk_frame::prelude::BlockNumberFor,
+            sp_runtime::{BoundedBTreeMap, BoundedBTreeSet},
+        };
+
+        use super::*;
+        use crate::permission::*;
+
+        #[derive(Encode, Decode)]
+        pub struct StreamScope<T: Config> {
+            pub recipients: BoundedBTreeMap<T::AccountId, u16, T::MaxRecipientsPerPermission>,
+            pub allocation: StreamAllocation<T>,
+            pub distribution: DistributionControl<T>,
+            pub accumulating: bool,
+            pub recipient_managers: BoundedBTreeSet<T::AccountId, T::MaxControllersPerPermission>,
+            pub weight_setters: BoundedBTreeSet<T::AccountId, T::MaxControllersPerPermission>,
+        }
+
+        #[derive(Encode, Decode)]
+        pub enum PermissionScope<T: Config> {
+            Stream(StreamScope<T>),
+            Curator(CuratorScope<T>),
+            Namespace(NamespaceScope<T>),
+            Wallet(wallet::WalletScope<T>),
+        }
+
+        #[derive(Encode, Decode)]
+        pub struct PermissionContract<T: Config> {
+            pub delegator: T::AccountId,
+            pub scope: PermissionScope<T>,
+            pub duration: PermissionDuration<T>,
+            pub revocation: RevocationTerms<T>,
+            pub enforcement: EnforcementAuthority<T>,
+            pub last_update: BlockNumberFor<T>,
+            pub last_execution: Option<BlockNumberFor<T>>,
+            pub execution_count: u32,
+            pub created_at: BlockNumberFor<T>,
+        }
+    }
+
+    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV8<T> {
+        fn on_runtime_upgrade() -> Weight {
+            let mut weight = Weight::zero();
+            let mut translated = 0u64;
+
+            Permissions::<T>::translate(|_key: PermissionId, old: old::PermissionContract<T>| {
+                weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
+                translated = translated.saturating_add(1);
+
+                let new_scope = match old.scope {
+                    old::PermissionScope::Stream(old_stream) => {
+                        crate::PermissionScope::Stream(crate::StreamScope {
+                            recipients: old_stream.recipients,
+                            allocation: old_stream.allocation,
+                            distribution: old_stream.distribution,
+                            accumulating: old_stream.accumulating,
+                            recipient_managers: old_stream.recipient_managers,
+                            weight_setters: old_stream.weight_setters,
+                            funnels: BoundedVec::default(),
+                        })
+                    }
+                    old::PermissionScope::Curator(curator) => {
+                        crate::PermissionScope::Curator(curator)
+                    }
+                    old::PermissionScope::Namespace(namespace) => {
+                        crate::PermissionScope::Namespace(namespace)
+                    }
+                    old::PermissionScope::Wallet(wallet) => crate::PermissionScope::Wallet(wallet),
+                };
+
+                Some(crate::PermissionContract {
+                    delegator: old.delegator,
+                    scope: new_scope,
+                    duration: old.duration,
+                    revocation: old.revocation,
+                    enforcement: old.enforcement,
+                    last_update: old.last_update,
+                    last_execution: old.last_execution,
+                    execution_count: old.execution_count,
+                    created_at: old.created_at,
+                })
+            });
+
+            weight
+        }
+    }
+}