introduce a transfer limit and duration for the AnyWithLimit proxy type

Author: Nathy-bajo

substrate/frame/proxy/src/lib.rs

@@ -75,6 +75,10 @@ pub struct ProxyDefinition<AccountId, ProxyType, BlockNumber> {
 	/// The number of blocks that an announcement must be in place for before the corresponding
 	/// call may be dispatched. If zero, then no announcement is needed.
 	pub delay: BlockNumber,
+	/// The maximun amount that can be transferred by this proxy.
+	pub max_amount: Option<BalanceOf<T>>,
+	/// The block number until which the limit is valid.
+	pub valid_unil: BlockNumber,
 }
 
 /// Details surrounding a specific instance of an announcement to make a call.
@@ -88,26 +92,6 @@ pub struct Announcement<AccountId, Hash, BlockNumber> {
 	height: BlockNumber,
 }
 
-/// The type of deposit
-#[derive(
-	Encode,
-	Decode,
-	Clone,
-	Copy,
-	Eq,
-	PartialEq,
-	RuntimeDebug,
-	MaxEncodedLen,
-	TypeInfo,
-	DecodeWithMemTracking,
-)]
-pub enum DepositKind {
-	/// Proxy registration deposit
-	Proxies,
-	/// Announcement deposit
-	Announcements,
-}
-
 #[frame::pallet]
 pub mod pallet {
 	use super::*;
@@ -170,6 +154,10 @@ pub mod pallet {
 		#[pallet::constant]
 		type MaxPending: Get<u32>;
 
+		#[pallet::constant]
+		type MaxTransferAmount: Get<BalanceOf<Self>>;
+
+
 		/// The type of hash used for hashing the call.
 		type CallHasher: Hash;
 
@@ -264,10 +252,12 @@ pub mod pallet {
 			delegate: AccountIdLookupOf<T>,
 			proxy_type: T::ProxyType,
 			delay: BlockNumberFor<T>,
+			max_amount: Option<BalanceOf<T>>,
+			valid_unil: BlockNumberFor<T>,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let delegate = T::Lookup::lookup(delegate)?;
-			Self::add_proxy_delegate(&who, delegate, proxy_type, delay)
+			Self::add_proxy_delegate(&who, delegate, proxy_type, delay, max_amount, valid_unil)
 		}
 
 		/// Unregister a proxy account for the sender.
@@ -329,14 +319,16 @@ pub mod pallet {
 			proxy_type: T::ProxyType,
 			delay: BlockNumberFor<T>,
 			index: u16,
+			max_amount: Option<BalanceOf<T>>,
+			valid_unil: BlockNumberFor<T>,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 
 			let pure = Self::pure_account(&who, &proxy_type, index, None);
 			ensure!(!Proxies::<T>::contains_key(&pure), Error::<T>::Duplicate);
 
 			let proxy_def =
-				ProxyDefinition { delegate: who.clone(), proxy_type: proxy_type.clone(), delay };
+				ProxyDefinition { delegate: who.clone(), proxy_type: proxy_type.clone(), delay, max_amount, valid_unil };
 			let bounded_proxies: BoundedVec<_, T::MaxProxies> =
 				vec![proxy_def].try_into().map_err(|_| Error::<T>::TooMany)?;
 
@@ -549,105 +541,6 @@ pub mod pallet {
 
 			Ok(())
 		}
-
-		/// Poke / Adjust deposits made for proxies and announcements based on current values.
-		/// This can be used by accounts to possibly lower their locked amount.
-		///
-		/// The dispatch origin for this call must be _Signed_.
-		///
-		/// The transaction fee is waived if the deposit amount has changed.
-		///
-		/// Emits `DepositPoked` if successful.
-		#[pallet::call_index(10)]
-		#[pallet::weight(T::WeightInfo::poke_deposit())]
-		pub fn poke_deposit(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
-			let who = ensure_signed(origin)?;
-			let mut deposit_updated = false;
-
-			// Check and update proxy deposits
-			Proxies::<T>::try_mutate_exists(&who, |maybe_proxies| -> DispatchResult {
-				let (proxies, old_deposit) = maybe_proxies.take().unwrap_or_default();
-				let maybe_new_deposit = Self::rejig_deposit(
-					&who,
-					old_deposit,
-					T::ProxyDepositBase::get(),
-					T::ProxyDepositFactor::get(),
-					proxies.len(),
-				)?;
-
-				match maybe_new_deposit {
-					Some(new_deposit) if new_deposit != old_deposit => {
-						*maybe_proxies = Some((proxies, new_deposit));
-						deposit_updated = true;
-						Self::deposit_event(Event::DepositPoked {
-							who: who.clone(),
-							kind: DepositKind::Proxies,
-							old_deposit,
-							new_deposit,
-						});
-					},
-					Some(_) => {
-						*maybe_proxies = Some((proxies, old_deposit));
-					},
-					None => {
-						*maybe_proxies = None;
-						if !old_deposit.is_zero() {
-							deposit_updated = true;
-							Self::deposit_event(Event::DepositPoked {
-								who: who.clone(),
-								kind: DepositKind::Proxies,
-								old_deposit,
-								new_deposit: BalanceOf::<T>::zero(),
-							});
-						}
-					},
-				}
-				Ok(())
-			})?;
-
-			// Check and update announcement deposits
-			Announcements::<T>::try_mutate_exists(&who, |maybe_announcements| -> DispatchResult {
-				let (announcements, old_deposit) = maybe_announcements.take().unwrap_or_default();
-				let maybe_new_deposit = Self::rejig_deposit(
-					&who,
-					old_deposit,
-					T::AnnouncementDepositBase::get(),
-					T::AnnouncementDepositFactor::get(),
-					announcements.len(),
-				)?;
-
-				match maybe_new_deposit {
-					Some(new_deposit) if new_deposit != old_deposit => {
-						*maybe_announcements = Some((announcements, new_deposit));
-						deposit_updated = true;
-						Self::deposit_event(Event::DepositPoked {
-							who: who.clone(),
-							kind: DepositKind::Announcements,
-							old_deposit,
-							new_deposit,
-						});
-					},
-					Some(_) => {
-						*maybe_announcements = Some((announcements, old_deposit));
-					},
-					None => {
-						*maybe_announcements = None;
-						if !old_deposit.is_zero() {
-							deposit_updated = true;
-							Self::deposit_event(Event::DepositPoked {
-								who: who.clone(),
-								kind: DepositKind::Announcements,
-								old_deposit,
-								new_deposit: BalanceOf::<T>::zero(),
-							});
-						}
-					},
-				}
-				Ok(())
-			})?;
-
-			Ok(if deposit_updated { Pays::No.into() } else { Pays::Yes.into() })
-		}
 	}
 
 	#[pallet::event]
@@ -679,13 +572,6 @@ pub mod pallet {
 			proxy_type: T::ProxyType,
 			delay: BlockNumberFor<T>,
 		},
-		/// A deposit stored for proxies or announcements was poked / updated.
-		DepositPoked {
-			who: T::AccountId,
-			kind: DepositKind,
-			old_deposit: BalanceOf<T>,
-			new_deposit: BalanceOf<T>,
-		},
 	}
 
 	#[pallet::error]
@@ -706,6 +592,10 @@ pub mod pallet {
 		Unannounced,
 		/// Cannot add self as proxy.
 		NoSelfProxy,
+		/// The transfer amoun exceeds the allowed limit.
+		TransferLimitExceeded,
+		/// The duration for the transfer limit has expired.
+		DurationExpired,
 	}
 
 	/// The set of account proxies. Maps the account which has delegated to the accounts
@@ -818,13 +708,25 @@ impl<T: Config> Pallet<T> {
 		delegatee: T::AccountId,
 		proxy_type: T::ProxyType,
 		delay: BlockNumberFor<T>,
+		max_amount: Option<BalanceOf<T>>,
+		valid_unil: BlockNumberFor<T>,
 	) -> DispatchResult {
 		ensure!(delegator != &delegatee, Error::<T>::NoSelfProxy);
 		Proxies::<T>::try_mutate(delegator, |(ref mut proxies, ref mut deposit)| {
 			let proxy_def = ProxyDefinition {
 				delegate: delegatee.clone(),
 				proxy_type: proxy_type.clone(),
 				delay,
+				max_amount: if proxy_type == ProxyType::AnyWithLimit {
+					max_amount
+				} else {
+					None
+				},
+				valid_unil: if proxy_type = ProxyType::AnyWithLimit {
+					valid_unil
+				} else {
+					None
+				},
 			};
 			let i = proxies.binary_search(&proxy_def).err().ok_or(Error::<T>::Duplicate)?;
 			proxies.try_insert(i, proxy_def).map_err(|_| Error::<T>::TooMany)?;
@@ -858,13 +760,25 @@ impl<T: Config> Pallet<T> {
 		delegatee: T::AccountId,
 		proxy_type: T::ProxyType,
 		delay: BlockNumberFor<T>,
+		max_amount: Option<BalanceOf<T>>,
+		valid_until: BlockNumberFor<T>,
 	) -> DispatchResult {
 		Proxies::<T>::try_mutate_exists(delegator, |x| {
 			let (mut proxies, old_deposit) = x.take().ok_or(Error::<T>::NotFound)?;
 			let proxy_def = ProxyDefinition {
 				delegate: delegatee.clone(),
 				proxy_type: proxy_type.clone(),
 				delay,
+				max_amount: if proxy_type == ProxyType::AnyWithLimit {
+					max_amount
+				} else {
+					None
+				},
+				valid_until: if proxy_type == ProxyType::AnytWithLimit {
+					valid_unil
+				} else {
+					None
+				},
 			};
 			let i = proxies.binary_search(&proxy_def).ok().ok_or(Error::<T>::NotFound)?;
 			proxies.remove(i);
@@ -905,16 +819,9 @@ impl<T: Config> Pallet<T> {
 		let new_deposit =
 			if len == 0 { BalanceOf::<T>::zero() } else { base + factor * (len as u32).into() };
 		if new_deposit > old_deposit {
-			T::Currency::reserve(who, new_deposit.saturating_sub(old_deposit))?;
+			T::Currency::reserve(who, new_deposit - old_deposit)?;
 		} else if new_deposit < old_deposit {
-			let excess = old_deposit.saturating_sub(new_deposit);
-			let remaining_unreserved = T::Currency::unreserve(who, excess);
-			if !remaining_unreserved.is_zero() {
-				defensive!(
-					"Failed to unreserve full amount. (Requested, Actual)",
-					(excess, excess.saturating_sub(remaining_unreserved))
-				);
-			}
+			T::Currency::unreserve(who, old_deposit - new_deposit);
 		}
 		Ok(if len == 0 { None } else { Some(new_deposit) })
 	}
@@ -977,7 +884,24 @@ impl<T: Config> Pallet<T> {
 				Some(Call::remove_proxies { .. }) | Some(Call::kill_pure { .. })
 					if def.proxy_type != T::ProxyType::default() =>
 					false,
-				_ => def.proxy_type.filter(c),
+					// Enforce the max_amount and duration limits for `AnyWithLimit` proxies.
+					if def.proxy_type == ProxyType::AnyWithLimit {
+						if let Some(Call::Balances(BalancesCall::transfer_allow_death { value, .. })) = c.is_sub_type() {
+							if let Some(max_amount) = def.max_amount {
+								if *value > max_amount {
+									return false; 
+								}
+							}
+							// Check the duration limit
+							if let Some(duration) = def.duration {
+								let current_block = T::BlockNumberProvider::current_block_number();
+								if current_block > def.delay + valid_unil {
+									return false; 
+								}
+							}
+						}
+			 def.proxy_type.filter(c),
+					}
 			}
 		});
 		let e = call.dispatch(origin);

substrate/frame/proxy/src/tests.rs

@@ -73,6 +73,7 @@ pub enum ProxyType {
 	Any,
 	JustTransfer,
 	JustUtility,
+	AnyWithLimit,
 }
 impl Default for ProxyType {
 	fn default() -> Self {
@@ -90,10 +91,21 @@ impl frame::traits::InstanceFilter<RuntimeCall> for ProxyType {
 				)
 			},
 			ProxyType::JustUtility => matches!(c, RuntimeCall::Utility { .. }),
+			ProxyType::AnyWithLimit => {
+				if let RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death { value, .. }) = c.is_sub_type() {
+					true
+				} else {
+					true
+				}
+			},
 		}
 	}
 	fn is_superset(&self, o: &Self) -> bool {
-		self == &ProxyType::Any || self == o
+		match (self, 0) {
+			(ProxyType::Any, _) => true,
+			(ProxyType::AnyWithLimit, ProxyType::AnyWithLimit) => true, 
+			_ => self == 0,
+		}
 	}
 }
 pub struct BaseFilter;
@@ -823,3 +835,29 @@ fn poke_deposit_fails_for_unsigned_origin() {
 		assert_noop!(Proxy::poke_deposit(RuntimeOrigin::none()), DispatchError::BadOrigin,);
 	});
 }
+
+#[test]
+fn set_transfer_limit_works() {
+    new_test_ext().execute_with(|| {
+        assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::AnyWithLimit, 0));
+        assert_ok!(Proxy::set_transfer_limit(RuntimeOrigin::signed(1), 2, 100, 10));
+        let def = Proxies::<Test>::get(1).0[0].clone();
+        assert_eq!(def.max_amount, Some(100));
+        assert_eq!(def.valid_until, 10);
+    });
+}
+
+#[test]
+fn transfer_with_limit_works() {
+    new_test_ext().execute_with(|| {
+        assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::AnyWithLimit, 0));
+        assert_ok!(Proxy::set_transfer_limit(RuntimeOrigin::signed(1), 2, 100, 10));
+        let call = Box::new(call_transfer(6, 50));
+        assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call));
+        let call = Box::new(call_transfer(6, 150));
+        assert_noop!(
+            Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call),
+            Error::<Test>::Unproxyable
+        );
+    });
+}