Optimistic Project Funding

Cargo.toml

@@ -338,6 +338,7 @@ members = [
 	"substrate/frame/core-fellowship",
 	"substrate/frame/delegated-staking",
 	"substrate/frame/democracy",
+	"substrate/frame/distribution",
 	"substrate/frame/election-provider-multi-phase",
 	"substrate/frame/election-provider-multi-phase/test-staking-e2e",
 	"substrate/frame/election-provider-support",
@@ -904,6 +905,7 @@ pallet-default-config-example = { path = "substrate/frame/examples/default-confi
 pallet-delegated-staking = { path = "substrate/frame/delegated-staking", default-features = false }
 pallet-democracy = { path = "substrate/frame/democracy", default-features = false }
 pallet-dev-mode = { path = "substrate/frame/examples/dev-mode", default-features = false }
+pallet-distribution = { path = "substrate/frame/distribution", default-features = false }
 pallet-election-provider-multi-phase = { path = "substrate/frame/election-provider-multi-phase", default-features = false }
 pallet-election-provider-support-benchmarking = { path = "substrate/frame/election-provider-support/benchmarking", default-features = false }
 pallet-elections-phragmen = { path = "substrate/frame/elections-phragmen", default-features = false }

docs/sdk/Cargo.toml

@@ -89,6 +89,7 @@ pallet-scheduler = { workspace = true, default-features = true }
 pallet-referenda = { workspace = true, default-features = true }
 pallet-broker = { workspace = true, default-features = true }
 pallet-babe = { workspace = true, default-features = true }
+pallet-distribution = { workspace = true, default-features = true }
 
 # Primitives
 sp-io = { workspace = true, default-features = true }

substrate/bin/node/runtime/src/lib.rs

@@ -2130,6 +2130,42 @@ impl pallet_broker::Config for Runtime {
 	type PriceAdapter = pallet_broker::CenterTargetPrice<Balance>;
 }
 
+
+parameter_types! {
+	// Id of the treasury
+	pub const PotId: PalletId = PalletId(*b"py/trsry");
+
+	// Time needed after approval to unlock the reward claim
+	pub const Period:BlockNumber = DAYS;
+
+	// Maximum number of whitelisted projects
+	pub const MaxProjects:u32 = 50;
+
+	pub const EpochDurationBlocks: BlockNumber = EPOCH_DURATION_IN_BLOCKS;
+
+}
+impl pallet_distribution::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+
+	type NativeBalance = Balances;
+
+	/// Pot PalletId
+	type PotId = PotId;
+
+	/// A reason for placing a hold on funds.
+	type RuntimeHoldReason = RuntimeHoldReason;
+
+	/// This the minimum required time period between project whitelisting
+	/// and payment/reward_claim from the treasury.
+	type PaymentPeriod = Period;
+
+	/// Maximum number of whitelisted projects
+	type MaxProjects = MaxProjects;
+
+	/// Epoch duration in blocks
+	type EpochDurationBlocks = EpochDurationBlocks;
+}
+
 parameter_types! {
 	pub const MixnetNumCoverToCurrentBlocks: BlockNumber = 3;
 	pub const MixnetNumRequestsToCurrentBlocks: BlockNumber = 3;
@@ -2469,6 +2505,9 @@ mod runtime {
 
 	#[runtime::pallet_index(79)]
 	pub type AssetConversionMigration = pallet_asset_conversion_ops::Pallet<Runtime>;
+
+	#[runtime::pallet_index(80)]
+	pub type Distribution = pallet_distribution::Pallet<Runtime>;
 }
 
 /// The address format for describing accounts.

substrate/frame/distribution/Cargo.toml

@@ -0,0 +1,67 @@
+[package]
+name = "pallet-distribution"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository.workspace = true
+description = "FRAME pallet to distribute funds to whitelisted projects"
+readme = "README.md"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true, default-features = false }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true , default-features = false }
+frame-benchmarking = { optional = true, workspace = true , default-features = false }
+frame-support = { workspace = true , default-features = false }
+frame-system = { workspace = true , default-features = false }
+sp-io = { workspace = true , default-features = false }
+sp-runtime = { workspace = true , default-features = false }
+sp-core = { workspace = true , default-features = false }
+
+pallet-assets = { workspace = true, default-features = false }
+pallet-balances = { workspace = true, default-features = false }
+pallet-timestamp = { workspace = true, default-features = false }
+pallet-sudo = { workspace = true, default-features = false }
+pallet-transaction-payment = { workspace = true, default-features = false }
+pallet-transaction-payment-rpc-runtime-api = { workspace = true, default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"log/std",
+	"scale-info/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-timestamp/std",
+	"pallet-sudo/std",
+	"pallet-transaction-payment-rpc-runtime-api/std",
+	"pallet-transaction-payment/std",
+	"pallet-assets/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]

substrate/frame/distribution/src/functions.rs

@@ -0,0 +1,149 @@
+pub use super::*;
+impl<T: Config> Pallet<T> {
+
+
+	pub fn pot_account() -> T::AccountId{
+		// Get Pot account
+		let pot_id = T::PotId::get();
+		let pot_account: T::AccountId = pot_id.into_account_truncating();
+		pot_account
+	}
+
+	pub fn get_spending(project_account: T::AccountId) -> Vec<SpendingIndex> {
+		let mut spendings: Vec<SpendingIndex>  = Vec::new();		
+		let mut value = Some(project_account);
+
+		for spending in Spendings::<T>::iter() {
+			let info = spending.1;
+			if info.whitelisted_project == value {
+				spendings.push(spending.0);
+			} 
+		} 
+
+		spendings
+	}
+
+    /// Series of checks on the Pot, to ensure that we have enough funds
+	/// before executing a spending
+	pub fn pot_check(amount: BalanceOf<T>) -> DispatchResult {
+
+		// Get Pot account		
+		let pot_account: T::AccountId = Self::pot_account();
+
+		// Check that the Pot as enough funds for the transfer
+        let balance = T::NativeBalance::balance(&pot_account);
+        let minimum_balance = T::NativeBalance::minimum_balance();
+		let remaining_balance = balance.saturating_sub(amount);
+
+		ensure!(remaining_balance > minimum_balance, Error::<T>::InsufficientPotReserves);
+		ensure!(balance > amount, Error::<T>::InsufficientPotReserves);
+		Ok(())
+	}
+
+
+	/// Funds transfer from the Pot to a project account
+	pub fn spending(
+		amount: BalanceOf<T>,
+		beneficiary: T::AccountId,
+		spending_index: u32,
+	) -> DispatchResult {
+
+		// Get Pot account
+		let pot_account: T::AccountId = Self::pot_account();
+
+		//Operate the transfer
+		let result = T::NativeBalance::transfer(
+			&pot_account,
+			&beneficiary,
+			amount,
+			Preservation::Preserve,
+		)
+		.map_err(|_| Error::<T>::TransferFailed);
+
+		Self::process_failed_spending_result(spending_index, result)?;
+
+
+		Ok(())
+	}
+
+	/// Helper function used to change the status of a failed spending
+	pub fn process_failed_spending_result(
+		spending_index: u32,
+		result: Result<BalanceOf<T>, Error<T>>,
+	) -> Result<BalanceOf<T>, Error<T>> {
+		match result {
+			Ok(x) => {
+				//Change spending status
+				Spendings::<T>::mutate(spending_index, |val| {
+					let mut val0 = val.clone().unwrap();
+					val0.status = SpendingState::Completed;
+					*val = Some(val0);
+				});
+				Ok(x)
+			},
+			Err(_e) => {
+				//Change spending status
+				Spendings::<T>::mutate(spending_index, |val| {
+					let mut val0 = val.clone().unwrap();
+					val0.status = SpendingState::Failed;
+					*val = Some(val0);
+				});
+				Err(Error::<T>::FailedSpendingOperation)
+			},
+		}
+	}
+
+	// ToDo in begin_block
+	// At the beginning of every Epoch, populate the `Spendings` storage from the `Projects` storage (populated by an external process/pallet)
+	// make sure that there is enough funds before creating a new `SpendingInfo`, and `ProjectInfo`
+	// corresponding to a created `SpendingInfo` should be removed from the `Projects` storage.
+	// This is also a good place to lock the funds for created `SpendingInfos`.
+	// the function will be use in a hook.
+
+	pub fn begin_block(now: BlockNumberFor<T>) -> Weight {
+		let max_block_weight = Weight::from_parts(1000_u64, 0);
+		let epoch = T::EpochDurationBlocks::get();
+
+		//We reach the check period
+		if (now % epoch).is_zero(){
+			let mut projects = Projects	::<T>::get();
+
+			if projects.len() > 0 {
+
+				for project in projects.clone(){
+					// check if the pot has enough fund for the spending
+					let check = Self::pot_check(project.amount);
+					let result = match check{
+
+						Ok(x) => {
+							// Create a new spending
+							let new_spending = SpendingInfo::<T>::new(project.clone());
+
+							// Lock funds for the project
+							let pot = Self::pot_account();
+							let _=T::NativeBalance::hold(
+								&HoldReason::FundsLock.into(),
+								&pot,
+								project.amount,
+							);
+
+							// remove project from project_list
+							projects.retain(|value| *value != project); 
+							Ok(x)
+
+						},
+						Err(_e) => Err(Error::<T>::InsufficientPotReserves)
+					};
+
+				}
+			}
+
+			// Update project storage
+			Projects::<T>::mutate(|val|{
+				*val = projects;
+			});
+		}
+		max_block_weight
+	}
+
+}