A Vision for More Friendly Balances and Currencies

[shawntabrizi]

The entire FRAME ecosystem revolves around the Balances pallet. In fact, nearly every pallet in FRAME uses the Currency trait, which currently is only implemented by our Balances pallet.

The Currency trait itself is not very well designed imo. It exposes functions which are implementation details of how the Balances pallet works, for example Negative/Positive imbalance.

It also assumes that every pallet needs extreme access to a currency, for example to be able to mint it, burn it, set anyone's balance, etc...

I think that we can turn the Currency pallet into a bunch of smaller, more ergonomic traits, and also reduce the trait requirements of many of our FRAME pallets. This would make them MUCH more friendly to alternative implementations of Balances-like pallets, especially when keeping in mind the need for multi-currenty chains of the future.

This is a meta issue to track the following independent tasks:

• Research, Design, and Define a new set of Currency traits which have in mind the MINIMAL set of functions needed to be exposed to be used by various pallets.
• Implement these traits into Substrate and FRAME primitives.
• Implement these traits into the Balances pallet.
• Downgrade all Currency requirements where possible across existing pallets.
• Create a "Simple Balances" pallet as an alternative to the balances pallet, something that would be a simple example for any new runtime developer to understand.
• Traitify the Assets Pallet using these minimal traits

Some ideas:

trait Currency {
    fn total_supply() -> Balance;
    fn minimum_balance() -> Balance;
    fn free_balance(who: AccountId) -> Balance;
    fn transfer(from: AccountId, to: AccountId, amount: Balance) -> Result;
}

trait ReservableCurrency: Currency {
    fn reserved_balance(who: AccountId) -> Balance;
    fn reserve(who: AccountId, amount: Balance) -> Result;
    fn unreserve(who: AccountId, amount: Balance) -> Balance;
}

trait MintableCurrency: Currency {
    fn mint(who: AccountId, amount: AccountId);
}

trait BurnableCurrency: Currency {
    fn burn(who: AccountId, amount: AccountId);
}

etc...

[xlc]

A version without imbalance will be useful. We have already made one in ORML: https://github.com/open-web3-stack/open-runtime-module-library/blob/92db458616cae0da1cc55fa90962e2ed16d45279/traits/src/currency.rs#L187

Also some multi currency support is needed like https://github.com/open-web3-stack/open-runtime-module-library/blob/92db458616cae0da1cc55fa90962e2ed16d45279/traits/src/currency.rs#L16

pallet-assets should also implement some of those new traits.

[shawntabrizi]

Yes to all of the above. Very happy to steal from you all as much as it makes sense so we can avoid duplication of work.

For example, in your BasicCurrency, I wouldn't include withdraw / deposit / slash. Do you think there is reason to have them in the minimal currency?

[xlc]

A version without withdraw / deposit / slash will be useful for a fixed supply token to enforce no mint / burn.

[shawntabrizi]

Exactly. Yeah, then seems we are very much aligned here. 👍

[shaunxw]

It seems #8435 is related to this issue.

[shaunxw]

To make traits minimal, I think they don't have to inherit from the base trait Currency. We can compose them instead if needed, like:

pub trait Config: frame_system::Config {
    type ReservableCurrency: Currency + Reservable;
}

[stale]

Hey, is anyone still working on this? Due to the inactivity this issue has been automatically marked as stale. It will be closed if no further activity occurs. Thank you for your contributions.

[kianenigma]

This will be addressed as part of paritytech/polkadot-sdk#327