Skip to content
  • Muharem Ismailov's avatar
    Treasury spends various asset kinds (#1333) · cb944dc5
    Muharem Ismailov authored
    
    
    ### Summary 
    
    This PR introduces new dispatchables to the treasury pallet, allowing
    spends of various asset types. The enhanced features of the treasury
    pallet, in conjunction with the asset-rate pallet, are set up and
    enabled for Westend and Rococo.
    
    ### Westend and Rococo runtimes.
    
    Polkadot/Kusams/Rococo Treasury can accept proposals for `spends` of
    various asset kinds by specifying the asset's location and ID.
    
    #### Treasury Instance New Dispatchables:
    - `spend(AssetKind, AssetBalance, Beneficiary, Option<ValidFrom>)` -
    propose and approve a spend;
    - `payout(SpendIndex)` - payout an approved spend or retry a failed
    payout
    - `check_payment(SpendIndex)` - check the status of a payout;
    - `void_spend(SpendIndex)` - void previously approved spend;
    > existing spend dispatchable renamed to spend_local
    
    in this context, the `AssetKind` parameter contains the asset's location
    and it's corresponding `asset_id`, for example:
    `USDT` on `AssetHub`,
    ``` rust
    location = MultiLocation(0, X1(Parachain(1000)))
    asset_id = MultiLocation(0, X2(PalletInstance(50), GeneralIndex(1984)))
    ```
    
    the `Beneficiary` parameter is a `MultiLocation` in the context of the
    asset's location, for example
    ``` rust
    // the Fellowship salary pallet's location / account
    FellowshipSalaryPallet = MultiLocation(1, X2(Parachain(1001), PalletInstance(64)))
    // or custom `AccountId`
    Alice = MultiLocation(0, AccountId32(network: None, id: [1,...]))
    ```
    
    the `AssetBalance` represents the amount of the `AssetKind` to be
    transferred to the `Beneficiary`. For permission checks, the asset
    amount is converted to the native amount and compared against the
    maximum spendable amount determined by the commanding spend origin.
    
    the `spend` dispatchable allows for batching spends with different
    `ValidFrom` arguments, enabling milestone-based spending. If the
    expectations tied to an approved spend are not met, it is possible to
    void the spend later using the `void_spend` dispatchable.
    
    Asset Rate Pallet provides the conversion rate from the `AssetKind` to
    the native balance.
    
    #### Asset Rate Instance Dispatchables:
    - `create(AssetKind, Rate)` - initialize a conversion rate to the native
    balance for the given asset
    - `update(AssetKind, Rate)` - update the conversion rate to the native
    balance for the given asset
    - `remove(AssetKind)` - remove an existing conversion rate to the native
    balance for the given asset
    
    the pallet's dispatchables can be executed by the Root or Treasurer
    origins.
    
    ### Treasury Pallet
    
    Treasury Pallet can accept proposals for `spends` of various asset kinds
    and pay them out through the implementation of the `Pay` trait.
    
    New Dispatchables:
    - `spend(Config::AssetKind, AssetBalance, Config::Beneficiary,
    Option<ValidFrom>)` - propose and approve a spend;
    - `payout(SpendIndex)` - payout an approved spend or retry a failed
    payout;
    - `check_payment(SpendIndex)` - check the status of a payout;
    - `void_spend(SpendIndex)` - void previously approved spend;
    > existing spend dispatchable renamed to spend_local
    
    The parameters' types of the `spend` dispatchable exposed via the
    pallet's `Config` and allows to propose and accept a spend of a certain
    amount.
    
    An approved spend can be claimed via the `payout` within the
    `Config::SpendPeriod`. Clients provide an implementation of the `Pay`
    trait which can pay an asset of the `AssetKind` to the `Beneficiary` in
    `AssetBalance` units.
    
    The implementation of the Pay trait might not have an immediate final
    payment status, for example if implemented over `XCM` and the actual
    transfer happens on a remote chain.
    
    The `check_status` dispatchable can be executed to update the spend's
    payment state and retry the `payout` if the payment has failed.
    
    ---------
    
    Co-authored-by: default avatarjoe petrowski <[email protected]>
    Co-authored-by: command-bot <>
    cb944dc5