Struct pallet_treasury::Module

pub struct Module<T: Trait<I>, I: Instance = DefaultInstance>(_);

Implementations

impl<T: Trait<I> + 'static, I: Instance> Module<T, I>

pub fn proposal_count() -> ProposalIndex

Number of proposals that have been made.

pub fn proposals<K: EncodeLike<ProposalIndex>>(
    key: K
) -> Option<Proposal<T::AccountId, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance>>

Proposals that have been made.

pub fn approvals() -> Vec<ProposalIndex>

Proposal indices that have been approved but not yet awarded.

pub fn tips<K: EncodeLike<T::Hash>>(
    key: K
) -> Option<OpenTip<T::AccountId, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance, T::BlockNumber, T::Hash>>

Tips that are not yet completed. Keyed by the hash of (reason, who) from the value. This has the insecure enumerable hash function since the key itself is already guaranteed to be a secure hash.

pub fn reasons<K: EncodeLike<T::Hash>>(key: K) -> Option<Vec<u8>>

Simple preimage lookup from the reason's hash to the original data. Again, has an insecure enumerable hash since the key is guaranteed to be the result of a secure hash.

pub fn bounty_count() -> BountyIndex

Number of bounty proposals that have been made.

pub fn bounties<K: EncodeLike<BountyIndex>>(
    key: K
) -> Option<Bounty<T::AccountId, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance, T::BlockNumber>>

Bounties that have been made.

pub fn bounty_descriptions<K: EncodeLike<BountyIndex>>(
    key: K
) -> Option<Vec<u8>>

The description of each bounty.

pub fn bounty_approvals() -> Vec<BountyIndex>

Bounty indices that have been approved but not yet funded.

impl<T: Trait<I>, I: Instance> Module<T, I>

pub fn account_id() -> T::AccountId

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.

pub fn bounty_account_id(id: BountyIndex) -> T::AccountId

The account ID of a bounty account

pub fn migrate_retract_tip_for_tip_new()

Trait Implementations

impl<T: Trait<I>, I: Instance> Callable<T> for Module<T, I>

type Call = Call<T, I>

impl<T: Clone + Trait<I>, I: Clone + Instance> Clone for Module<T, I>

fn clone(&self) -> Module<T, I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy + Trait<I>, I: Copy + Instance> Copy for Module<T, I>

impl<T: Trait<I>, I: Instance> Debug for Module<T, I> where
    T: Debug,
    I: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Eq + Trait<I>, I: Eq + Instance> Eq for Module<T, I>

impl<T: Trait<I>, I: Instance> IntegrityTest for Module<T, I>

fn integrity_test()

Run integrity test.

impl<T: Trait<I>, I: Instance> ModuleErrorMetadata for Module<T, I>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait + Trait<I>, I: Instance> OffchainWorker<<T as Trait>::BlockNumber> for Module<T, I>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait + Trait<I>, I: Instance> OnFinalize<<T as Trait>::BlockNumber> for Module<T, I>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait + Trait<I>, I: Instance> OnInitialize<<T as Trait>::BlockNumber> for Module<T, I>

fn on_initialize(n: T::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

impl<T: Trait<I>, I: Instance> OnRuntimeUpgrade for Module<T, I>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: Trait<I>, I: Instance> OnUnbalanced<<<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::NegativeImbalance> for Module<T, I>

fn on_nonzero_unbalanced(
    amount: <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::NegativeImbalance
)

Actually handle a non-zero imbalance. You probably want to implement this rather than on_unbalanced.

fn on_unbalanceds<B>(amounts: impl Iterator<Item = Imbalance>) where
    Imbalance: Imbalance<B>, 

Handler for some imbalances. The different imbalances might have different origins or meanings, dependent on the context. Will default to simply calling on_unbalanced for all of them. Infallible.

fn on_unbalanced(amount: Imbalance)

Handler for some imbalance. Infallible.

impl<T: PartialEq + Trait<I>, I: PartialEq + Instance> PartialEq<Module<T, I>> for Module<T, I>

fn eq(&self, other: &Module<T, I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T, I>) -> bool

This method tests for !=.

impl<T: Trait<I>, I: Instance> StructuralEq for Module<T, I>

impl<T: Trait<I>, I: Instance> StructuralPartialEq for Module<T, I>