Struct noble_treasury::Module

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

Implementations

impl<T: Config<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, BalanceOf<T, I>>>

Proposals that have been made.

pub fn approvals() -> Vec<ProposalIndex>

Proposal indices that have been approved but not yet awarded.

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

Can also be called using Call.

pub fn propose_spend(
    origin: T::Origin,
    value: BalanceOf<T, I>,
    beneficiary: <T::Lookup as StaticLookup>::Source
) -> DispatchResult

Put forward a suggestion for spending. A deposit proportional to the value is reserved and slashed if the proposal is rejected. It is returned once the proposal is awarded.

• Complexity: O(1)
• DbReads: ProposalCount, origin account
• DbWrites: ProposalCount, Proposals, origin account

NOTE: Calling this function will bypass origin filters.

pub fn reject_proposal(
    origin: T::Origin,
    proposal_id: ProposalIndex
) -> DispatchResult

Reject a proposed spend. The original deposit will be slashed.

May only be called from T::RejectOrigin.

• Complexity: O(1)
• DbReads: Proposals, rejected proposer account
• DbWrites: Proposals, rejected proposer account

NOTE: Calling this function will bypass origin filters.

pub fn approve_proposal(
    origin: T::Origin,
    proposal_id: ProposalIndex
) -> DispatchResult

Approve a proposal. At a later time, the proposal will be allocated to the beneficiary and the original deposit will be returned.

May only be called from T::ApproveOrigin.

• Complexity: O(1).
• DbReads: Proposals, Approvals
• DbWrite: Approvals

NOTE: Calling this function will bypass origin filters.

impl<T: Config<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 spend_funds() -> Weight

Spend some money! returns number of approvals before spend.

pub fn pot() -> BalanceOf<T, I>

Return the amount of money in the pot.

Trait Implementations

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

type Call = Call<T, I>

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

impl<T: Config<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 + Config<I>, I: Eq + Instance> Eq for Module<T, I>

impl<T: Config<I>, I: Instance> GetNobleVersion for Module<T, I>

fn current_version() -> NobleVersion

Returns the current version of the noble.

fn storage_version() -> Option<NobleVersion>

Returns the version of the noble that is stored in storage.

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

pub fn integrity_test()

Run integrity test.

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

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

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

pub fn offchain_worker(_n: BlockNumber)

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

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

pub fn on_finalize(_n: BlockNumber)

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

impl<T: Config<I>, I: Instance> OnGenesis for Module<T, I>

fn on_genesis()

Something that should happen at genesis.

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

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

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

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

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

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

fn on_nonzero_unbalanced(amount: NegativeImbalanceOf<T, I>)

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

pub 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.

pub fn on_unbalanced(amount: Imbalance)

Handler for some imbalance. Infallible.

impl<T: PartialEq + Config<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: Config<I>, I: Instance> StructuralEq for Module<T, I>

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