How to support multiple currencies in pallet_treasury?

[clearloop]

Spec

propose_spend receive a Currency<AccountId>::Balance as an argument, what if we declare multiple currencies in Trait and write different logics?

1. Multiple currencies in pallet_treasury::Trait

pub trait Trait: frame_system::Trait {                                                                                                                                                                                    
    type CurrencyA: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;                                                                                                                                                                                  
    type CurrencyB: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
    // ...
}

2. propose_spend method in Call

pub enum Call<T: Trait> {
    propose_spend(
        balance: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, 
        source: <T::Lookup as StaticLookup>::Source
    ) {
        match balance {
                CurrencyA => {},
                CurrencyB => {},
        }
    }
    // ....
}

Is it possible to compose the Balance argument as an enum, or implement different traits to infer which currency is passing in?

I've just tried both of enum an trait and failed both of them.

enum solution

enum Balances {
    CurrencyA::Balance,
    CurrencyB::Balance,
}

Macro parse failed, lack of Encode and Decode trait, even derive them to the enum.

trait solution

enum BalanceMarker {
    A,
    B,
}

trait Marker {
    fn marker() -> BalanceMarker;
}

impl<_> Marker for CurrencyA::Balance<_> {
    // ...
}

impl<_> Marker for CurrencyB::Balance<_> {
    // ...
}

This seems impossible because Trait is totally all types and doesn't have Sized to compile.

sp_std::any::TypeId solution

Failed as trait one.

Wondering

If it is unnecessary or impossible implementing CurrencyA, CurrencyB.... in pallet_treasury? If it is, how can I reach different logics for different Balances in propose_spend method?

[bkchr]

Hey, that is currently not supported, but sounds like a good idea!

[clearloop]

Hi, we just got a solution as a reference,

// Currencies
trait Trait: system::Trait {
    type CurrencyA: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
    type CurrencyB: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
    type CommonBalanceT<T> = CommonBalance<BalanceA<T>, BalanceB<T>>;
}

// Balances
type BalanceA<T> = <CurrencyA<T> as Currency<AccountId<T>>>::Balance;
type BalanceB<T> = <CurrencyB<T> as Currency<AccountId<T>>>::Balance;
type CommonBalanceT<T> = CommonBalance<BalanceA<T>, BalanceB<T>>;

// The enum
#[derive(PartialEq, Eq, Clone, Encode, Decode)]
pub enum CommonBalance<A, B>
where
    A: HasCompact,
    B: HasCompact,
{
    BalanceA(A),
    BalanceB(B),
}

// propose_spend
fn propose_spend(
        origin,
        value: CommonBalanceT<T>,
        beneficiary: <T::Lookup as StaticLookup>::Source
) {
       match value { 
           // ... 
       }
}

Compose enum with currencies as generics.

[bkchr]

TY for reporting back.