[TASK] Define collator rewards and inflation strategy

[1xstj]

Inflationary rewards

We want to allocate a fraction of genesis tokens to collators over a 2 year period as well as define a mechanism for inflationary rewards once this amount of tokens runs out.

We’d like to target 1-5% inflation for

• collators
• treasury

Desired Outcome

• Every block payout
• The pallet account will receive an amount of tokens at genesis
• These tokens will be distributed at configured RewardAmount to the collators (block author)
• Once the genesis amount of tokens are depleted, the pallet will create new tokens
• New amount of tokens created every block according to inflation rate

Docs

• https://docs.webb.tools/v1/node-operators/payouts/

[1xstj]

Example Implementation

Create a new pallet reward-handler. The pallet will

• implement OnUnbalanced to accept the block_reward + tips
• calculate the amount of tokens to transfer based on inflation rate
• transfer block_reward + tips + new_tokens to block_author every block (or part to treasury)

Pallet Config

/// The pallet's configuration trait.
pub trait Config: frame_system::Config + pallet_balances::Config + pallet_treasury::Config {
	/// The overarching event type.
	type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;

	/// The amount of tokens to mint every block
	type RewardAmount: Get<Self::Balance>;

        /// PalletAccount
	type PalletAccount: Get<Self::AccountId>;
}

OnUnbalanced Handler

pub struct DealWithFees<R>(sp_std::marker::PhantomData<R>);
impl<R> OnUnbalanced<NegativeImbalance<R>> for DealWithFees<R>
{
	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance<R>>) {
		if let Some(fees) = fees_then_tips.next() {
			// for fees, 80% to treasury, 20% to author
			// We could also make this configurable
			let mut split = fees.ration(80, 20);
			if let Some(tips) = fees_then_tips.next() {
				// for tips, if any, 100% to author
				tips.merge_into(&mut split.1);
			}

                         // try to pay the collator reward amount from the pallet account
                         if Balances::can_transfer() {
                                  let block_author_reward = split.1 + Balances::withdraw(PalletAccount::get())
                         }
                         // if cannot pay from pallet account then add inlfation amount
                        else  {
                              // create new tokens
                              Balances::issue(T::RewardAmount::get())
                              let block_author_reward = split.1 + T::RewardAmount::get();
                         }

			<Treasury<R> as OnUnbalanced<_>>::on_unbalanced(split.0);
			<ToAuthor<R> as OnUnbalanced<_>>::on_unbalanced(block_author_reward);
		}
	}
}