// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// 	http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//! > Made with *Substrate*, for *Polkadot*.

//!

//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -

//! [![polkadot]](https://polkadot.network)

//!

//! [polkadot]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white

//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github

//!

//! # Treasury Pallet

//!

//! The Treasury pallet provides a "pot" of funds that can be managed by stakeholders in the system

//! and a structure for making spending proposals from this pot.

//!

//! ## Overview

//!

//! The Treasury Pallet itself provides the pot to store funds, and a means for stakeholders to

//! propose and claim expenditures (aka spends). The chain will need to provide a method to approve

//! spends (e.g. public referendum) and a method for collecting funds (e.g. inflation, fees).

//!

//! By way of example, stakeholders could vote to fund the Treasury with a portion of the block

//! reward and use the funds to pay developers.

//!

//! ### Terminology

//!

//! - **Proposal:** A suggestion to allocate funds from the pot to a beneficiary.

//! - **Beneficiary:** An account who will receive the funds from a proposal iff the proposal is

//!   approved.

//! - **Pot:** Unspent funds accumulated by the treasury pallet.

//! - **Spend** An approved proposal for transferring a specific amount of funds to a designated

//!   beneficiary.

//!

//! ### Example

//!

//! 1. Multiple local spends approved by spend origins and received by a beneficiary.

#![doc = docify::embed!("src/tests.rs", spend_local_origin_works)]

//!

//! 2. Approve a spend of some asset kind and claim it.

#![doc = docify::embed!("src/tests.rs", spend_payout_works)]

//!

//! ## Pallet API

//!

//! See the [`pallet`] module for more information about the interfaces this pallet exposes,

//! including its configuration trait, dispatchables, storage items, events and errors.

//!

//! ## Low Level / Implementation Details

//!

//! Spends can be initiated using either the `spend_local` or `spend` dispatchable. The

//! `spend_local` dispatchable enables the creation of spends using the native currency of the

//! chain, utilizing the funds stored in the pot. These spends are automatically paid out every

//! [`pallet::Config::SpendPeriod`]. On the other hand, the `spend` dispatchable allows spending of

//! any asset kind managed by the treasury, with payment facilitated by a designated

//! [`pallet::Config::Paymaster`]. To claim these spends, the `payout` dispatchable should be called

//! within some temporal bounds, starting from the moment they become valid and within one

//! [`pallet::Config::PayoutPeriod`].

#![cfg_attr(not(feature = "std"), no_std)]

mod benchmarking;

#[cfg(test)]

mod tests;

pub mod weights;

use core::marker::PhantomData;

#[cfg(feature = "runtime-benchmarks")]

pub use benchmarking::ArgumentsFactory;

extern crate alloc;

use codec::{Decode, Encode, MaxEncodedLen};

use scale_info::TypeInfo;

use alloc::{boxed::Box, collections::btree_map::BTreeMap};

use sp_runtime::{

	traits::{AccountIdConversion, CheckedAdd, Saturating, StaticLookup, Zero},

	Permill, RuntimeDebug,

};

use frame_support::{

	dispatch::{DispatchResult, DispatchResultWithPostInfo},

	ensure, print,

	traits::{

		tokens::Pay, Currency, ExistenceRequirement::KeepAlive, Get, Imbalance, OnUnbalanced,

		ReservableCurrency, WithdrawReasons,

	},

	weights::Weight,

	PalletId,

};

pub use pallet::*;

pub use weights::WeightInfo;

pub type BalanceOf<T, I = ()> =

	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;

pub type AssetBalanceOf<T, I> = <<T as Config<I>>::Paymaster as Pay>::Balance;

pub type PositiveImbalanceOf<T, I = ()> = <<T as Config<I>>::Currency as Currency<

	<T as frame_system::Config>::AccountId,

>>::PositiveImbalance;

pub type NegativeImbalanceOf<T, I = ()> = <<T as Config<I>>::Currency as Currency<

	<T as frame_system::Config>::AccountId,

>>::NegativeImbalance;

type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;

type BeneficiaryLookupOf<T, I> = <<T as Config<I>>::BeneficiaryLookup as StaticLookup>::Source;

/// A trait to allow the Treasury Pallet to spend it's funds for other purposes.

/// There is an expectation that the implementer of this trait will correctly manage

/// the mutable variables passed to it:

/// * `budget_remaining`: How much available funds that can be spent by the treasury. As funds are

///   spent, you must correctly deduct from this value.

/// * `imbalance`: Any imbalances that you create should be subsumed in here to maximize efficiency

///   of updating the total issuance. (i.e. `deposit_creating`)

/// * `total_weight`: Track any weight that your `spend_fund` implementation uses by updating this

///   value.

/// * `missed_any`: If there were items that you want to spend on, but there were not enough funds,

///   mark this value as `true`. This will prevent the treasury from burning the excess funds.

pub trait SpendFunds<T: Config<I>, I: 'static = ()> {

	fn spend_funds(

		budget_remaining: &mut BalanceOf<T, I>,

		imbalance: &mut PositiveImbalanceOf<T, I>,

		total_weight: &mut Weight,

		missed_any: &mut bool,

	);

}

/// An index of a proposal. Just a `u32`.

pub type ProposalIndex = u32;

/// A spending proposal.

pub struct Proposal<AccountId, Balance> {

	/// The account proposing it.

	proposer: AccountId,

	/// The (total) amount that should be paid if the proposal is accepted.

	value: Balance,

	/// The account to whom the payment should be made if the proposal is accepted.

	beneficiary: AccountId,

	/// The amount held on deposit (reserved) for making this proposal.

	bond: Balance,

}

/// The state of the payment claim.

pub enum PaymentState<Id> {

}

/// Info regarding an approved treasury spend.

pub struct SpendStatus<AssetKind, AssetBalance, Beneficiary, BlockNumber, PaymentId> {

	// The kind of asset to be spent.

	asset_kind: AssetKind,

	/// The asset amount of the spend.

	amount: AssetBalance,

	/// The beneficiary of the spend.

	beneficiary: Beneficiary,

	/// The block number from which the spend can be claimed.

	valid_from: BlockNumber,

	/// The block number by which the spend has to be claimed.

	expire_at: BlockNumber,

	/// The status of the payout/claim.

	status: PaymentState<PaymentId>,

}

/// Index of an approved treasury spend.

pub type SpendIndex = u32;

pub mod pallet {

	use super::*;

	use frame_support::{

		dispatch_context::with_context,

		pallet_prelude::*,

		traits::tokens::{ConversionFromAssetBalance, PaymentStatus},

	};

	use frame_system::pallet_prelude::*;

	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

	#[pallet::config]

	pub trait Config<I: 'static = ()>: frame_system::Config {

		/// The staking balance.

		type Currency: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;

		/// Origin from which rejections must come.

		type RejectOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// The overarching event type.

		type RuntimeEvent: From<Event<Self, I>>

			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Period between successive spends.

		#[pallet::constant]

		type SpendPeriod: Get<BlockNumberFor<Self>>;

		/// Percentage of spare funds (if any) that are burnt per spend period.

		#[pallet::constant]

		type Burn: Get<Permill>;

		/// The treasury's pallet id, used for deriving its sovereign account ID.

		#[pallet::constant]

		type PalletId: Get<PalletId>;

		/// Handler for the unbalanced decrease when treasury funds are burned.

		type BurnDestination: OnUnbalanced<NegativeImbalanceOf<Self, I>>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

		/// Runtime hooks to external pallet using treasury to compute spend funds.

		type SpendFunds: SpendFunds<Self, I>;

		/// The maximum number of approvals that can wait in the spending queue.

		///

		/// NOTE: This parameter is also used within the Bounties Pallet extension if enabled.

		#[pallet::constant]

		type MaxApprovals: Get<u32>;

		/// The origin required for approving spends from the treasury outside of the proposal

		/// process. The `Success` value is the maximum amount in a native asset that this origin

		/// is allowed to spend at a time.

		type SpendOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = BalanceOf<Self, I>>;

		/// Type parameter representing the asset kinds to be spent from the treasury.

		type AssetKind: Parameter + MaxEncodedLen;

		/// Type parameter used to identify the beneficiaries eligible to receive treasury spends.

		type Beneficiary: Parameter + MaxEncodedLen;

		/// Converting trait to take a source type and convert to [`Self::Beneficiary`].

		type BeneficiaryLookup: StaticLookup<Target = Self::Beneficiary>;

		/// Type for processing spends of [Self::AssetKind] in favor of [`Self::Beneficiary`].

		type Paymaster: Pay<Beneficiary = Self::Beneficiary, AssetKind = Self::AssetKind>;

		/// Type for converting the balance of an [Self::AssetKind] to the balance of the native

		/// asset, solely for the purpose of asserting the result against the maximum allowed spend

		/// amount of the [`Self::SpendOrigin`].

		type BalanceConverter: ConversionFromAssetBalance<

			<Self::Paymaster as Pay>::Balance,

			Self::AssetKind,

			BalanceOf<Self, I>,

		>;

		/// The period during which an approved treasury spend has to be claimed.

		#[pallet::constant]

		type PayoutPeriod: Get<BlockNumberFor<Self>>;

		/// Helper type for benchmarks.

		#[cfg(feature = "runtime-benchmarks")]

		type BenchmarkHelper: ArgumentsFactory<Self::AssetKind, Self::Beneficiary>;

	}

	/// Number of proposals that have been made.

	#[pallet::getter(fn proposal_count)]

	pub(crate) type ProposalCount<T, I = ()> = StorageValue<_, ProposalIndex, ValueQuery>;

	/// Proposals that have been made.

	#[pallet::getter(fn proposals)]

	pub type Proposals<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Twox64Concat,

		ProposalIndex,

		Proposal<T::AccountId, BalanceOf<T, I>>,

		OptionQuery,

	>;

	/// The amount which has been reported as inactive to Currency.

	pub type Deactivated<T: Config<I>, I: 'static = ()> =

		StorageValue<_, BalanceOf<T, I>, ValueQuery>;

	/// Proposal indices that have been approved but not yet awarded.

	#[pallet::getter(fn approvals)]

	pub type Approvals<T: Config<I>, I: 'static = ()> =

		StorageValue<_, BoundedVec<ProposalIndex, T::MaxApprovals>, ValueQuery>;

	/// The count of spends that have been made.

	pub(crate) type SpendCount<T, I = ()> = StorageValue<_, SpendIndex, ValueQuery>;

	/// Spends that have been approved and being processed.

	// Hasher: Twox safe since `SpendIndex` is an internal count based index.

	pub type Spends<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Twox64Concat,

		SpendIndex,

		SpendStatus<

			T::AssetKind,

			AssetBalanceOf<T, I>,

			T::Beneficiary,

			BlockNumberFor<T>,

			<T::Paymaster as Pay>::Id,

		>,

		OptionQuery,

	>;

	#[pallet::genesis_config]

	#[derive(frame_support::DefaultNoBound)]

	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {

		#[serde(skip)]

		_config: core::marker::PhantomData<(T, I)>,

	}

	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {

	}

	pub enum Event<T: Config<I>, I: 'static = ()> {

		SpendApproved {

		AssetSpendApproved {

		/// paid or it may have expired.

	}

	/// Error for the treasury pallet.

	pub enum Error<T, I = ()> {

	}

	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {

		/// ## Complexity

		/// - `O(A)` where `A` is the number of approvals

			// Check to see if we should spend some funds!

			} else {

			}

		#[cfg(feature = "try-runtime")]

	}

	#[derive(Default)]

	struct SpendContext<Balance> {

		spend_in_context: BTreeMap<Balance, Balance>,

	}

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Propose and approve a spend of treasury funds.

		///

		/// ## Dispatch Origin

		///

		/// Must be [`Config::SpendOrigin`] with the `Success` value being at least `amount`.

		///

		/// ### Details

		/// NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the

		/// beneficiary.

		///

		/// ### Parameters

		/// - `amount`: The amount to be transferred from the treasury to the `beneficiary`.

		/// - `beneficiary`: The destination account for the transfer.

		///

		/// ## Events

		///

		/// Emits [`Event::SpendApproved`] if successful.

		#[pallet::call_index(3)]

		#[pallet::weight(T::WeightInfo::spend_local())]

		pub fn spend_local(

			origin: OriginFor<T>,

			#[pallet::compact] amount: BalanceOf<T, I>,

			beneficiary: AccountIdLookupOf<T>,

				} else {

				}

		}

		/// Force a previously approved proposal to be removed from the approval queue.

		///

		/// ## Dispatch Origin

		///

		/// Must be [`Config::RejectOrigin`].

		///

		/// ## Details

		///

		/// The original deposit will no longer be returned.

		///

		/// ### Parameters

		/// - `proposal_id`: The index of a proposal

		///

		/// ### Complexity

		/// - O(A) where `A` is the number of approvals

		///

		/// ### Errors

		/// - [`Error::ProposalNotApproved`]: The `proposal_id` supplied was not found in the

		///   approval queue, i.e., the proposal has not been approved. This could also mean the

		///   proposal does not exist altogether, thus there is no way it would have been approved

		///   in the first place.

		#[pallet::call_index(4)]

		#[pallet::weight((T::WeightInfo::remove_approval(), DispatchClass::Operational))]

		pub fn remove_approval(

			origin: OriginFor<T>,

			#[pallet::compact] proposal_id: ProposalIndex,

				} else {

				}

		}

		/// Propose and approve a spend of treasury funds.

		///

		/// ## Dispatch Origin

		///

		/// Must be [`Config::SpendOrigin`] with the `Success` value being at least

		/// `amount` of `asset_kind` in the native asset. The amount of `asset_kind` is converted

		/// for assertion using the [`Config::BalanceConverter`].

		///

		/// ## Details

		///

		/// Create an approved spend for transferring a specific `amount` of `asset_kind` to a

		/// designated beneficiary. The spend must be claimed using the `payout` dispatchable within

		/// the [`Config::PayoutPeriod`].

		///

		/// ### Parameters

		/// - `asset_kind`: An indicator of the specific asset class to be spent.

		/// - `amount`: The amount to be transferred from the treasury to the `beneficiary`.

		/// - `beneficiary`: The beneficiary of the spend.

		/// - `valid_from`: The block number from which the spend can be claimed. It can refer to

		///   the past if the resulting spend has not yet expired according to the

		///   [`Config::PayoutPeriod`]. If `None`, the spend can be claimed immediately after

		///   approval.

		///

		/// ## Events

		///

		/// Emits [`Event::AssetSpendApproved`] if successful.

		#[pallet::call_index(5)]

		#[pallet::weight(T::WeightInfo::spend())]

		pub fn spend(

			origin: OriginFor<T>,

			asset_kind: Box<T::AssetKind>,

			#[pallet::compact] amount: AssetBalanceOf<T, I>,

			beneficiary: Box<BeneficiaryLookupOf<T, I>>,

			valid_from: Option<BlockNumberFor<T>>,

				} else {

				}

		}

		/// Claim a spend.

		///

		/// ## Dispatch Origin

		///

		/// Must be signed

		///

		/// ## Details

		///

		/// Spends must be claimed within some temporal bounds. A spend may be claimed within one

		/// [`Config::PayoutPeriod`] from the `valid_from` block.

		/// In case of a payout failure, the spend status must be updated with the `check_status`

		/// dispatchable before retrying with the current function.

		///

		/// ### Parameters

		/// - `index`: The spend index.

		///

		/// ## Events

		///

		/// Emits [`Event::Paid`] if successful.

		#[pallet::call_index(6)]

		#[pallet::weight(T::WeightInfo::payout())]

			);

		}

		/// Check the status of the spend and remove it from the storage if processed.

		///

		/// ## Dispatch Origin

		///

		/// Must be signed.

		///

		/// ## Details

		///

		/// The status check is a prerequisite for retrying a failed payout.

		/// If a spend has either succeeded or expired, it is removed from the storage by this

		/// function. In such instances, transaction fees are refunded.

		///

		/// ### Parameters

		/// - `index`: The spend index.

		///

		/// ## Events

		///

		/// Emits [`Event::PaymentFailed`] if the spend payout has failed.

		/// Emits [`Event::SpendProcessed`] if the spend payout has succeed.

		#[pallet::call_index(7)]

		#[pallet::weight(T::WeightInfo::check_status())]

			use PaymentState as State;

			use PaymentStatus as Status;

				// spend has expired and no further status update is expected.

			};

				Status::Success | Status::Unknown => {

				},

			}

		}

		/// Void previously approved spend.

		///

		/// ## Dispatch Origin

		///

		/// Must be [`Config::RejectOrigin`].

		///

		/// ## Details

		///

		/// A spend void is only possible if the payout has not been attempted yet.

		///

		/// ### Parameters

		/// - `index`: The spend index.

		///

		/// ## Events

		///

		/// Emits [`Event::AssetSpendVoided`] if successful.

		#[pallet::call_index(8)]

		#[pallet::weight(T::WeightInfo::void_spend())]

			);

		}

	}

}

impl<T: Config<I>, I: 'static> Pallet<T, I> {

	// Add public immutables and private mutables.

	/// The account ID of the treasury pot.

	///

	/// This actually does computation. If you need to keep using it, then make sure you cache the

	/// value and only call this once.

	/// Spend some money! returns number of approvals before spend.

				// Should always be true, but shouldn't panic if false or we're screwed.

						// provide the allocation.

					} else {

					}

				} else {

				}

			// burn some proportion of the remaining budget if we run a surplus.

		// Must never be an error, but better to be safe.

		// proof: budget_remaining is account free balance minus ED;

		// Thus we can't spend more than account free balance minus ED;

		// Thus account is kept alive; qed;

	/// Return the amount of money in the pot.

	// The existential deposit is not part of the pot so treasury account never gets deleted.

	/// Ensure the correctness of the state of this pallet.

	#[cfg(any(feature = "try-runtime", test))]

	/// ### Invariants of proposal storage items

	///

	/// 1. [`ProposalCount`] >= Number of elements in [`Proposals`].

	/// 2. Each entry in [`Proposals`] should be saved under a key strictly less than current

	/// [`ProposalCount`].

	/// 3. Each [`ProposalIndex`] contained in [`Approvals`] should exist in [`Proposals`].

	/// Note, that this automatically implies [`Approvals`].count() <= [`Proposals`].count().

	#[cfg(any(feature = "try-runtime", test))]

		);

			);

				);

	/// ## Invariants of spend storage items

	///

	/// 1. [`SpendCount`] >= Number of elements in [`Spends`].

	/// 2. Each entry in [`Spends`] should be saved under a key strictly less than current

	/// [`SpendCount`].

	/// 3. For each spend entry contained in [`Spends`] we should have spend.expire_at

	/// > spend.valid_from.

	#[cfg(any(feature = "try-runtime", test))]

		);

			);

			);

}

impl<T: Config<I>, I: 'static> OnUnbalanced<NegativeImbalanceOf<T, I>> for Pallet<T, I> {

}

/// TypedGet implementation to get the AccountId of the Treasury.

pub struct TreasuryAccountId<R>(PhantomData<R>);

impl<R> sp_runtime::traits::TypedGet for TreasuryAccountId<R>

where

	R: crate::Config,

{

	type Type = <R as frame_system::Config>::AccountId;

}