Struct sunshine_bank::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn treasury_id_nonce() -> OnChainTreasuryID

Counter for generating unique treasury identifiers

pub fn spend_nonce_map<K: EncodeLike<OnChainTreasuryID>>(key: K) -> T::SpendId

Counter for generating unique spend proposal identifiers

pub fn total_bank_count() -> u32

Total number of banks registered in this module

pub fn org_treasury_count<K: EncodeLike<T::OrgId>>(key: K) -> u32

The total number of treasury accounts per org

pub fn bank_stores<K: EncodeLike<OnChainTreasuryID>>(
    key: K
) -> Option<BankState<T::AccountId, T::OrgId>>

The store for organizational bank accounts -> keyset acts as canonical set for unique OnChainTreasuryIDs

pub fn spend_proposals<KArg1, KArg2>(
    k1: KArg1,
    k2: KArg2
) -> Option<SpendProposal<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, T::AccountId, SpendState<T::VoteId>>> where
    KArg1: EncodeLike<OnChainTreasuryID>,
    KArg2: EncodeLike<T::SpendId>, 

impl<T: Trait> Module<T>

pub fn is_bank(id: OnChainTreasuryID) -> bool

pub fn account_id(id: OnChainTreasuryID) -> T::AccountId

pub fn bank_balance(
    bank: OnChainTreasuryID
) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance

pub fn get_banks_for_org(
    org: T::OrgId
) -> Result<Vec<OnChainTreasuryID>, DispatchError>

Trait Implementations

impl<T: Trait> BankPermissions<OnChainTreasuryID, <T as Trait>::OrgId, <T as Trait>::AccountId> for Module<T>

fn can_open_bank_account_for_org(org: T::OrgId, who: &T::AccountId) -> bool

fn can_propose_spend(
    bank: OnChainTreasuryID,
    who: &T::AccountId
) -> Result<bool, DispatchError>

fn can_trigger_vote_on_spend_proposal(
    bank: OnChainTreasuryID,
    who: &T::AccountId
) -> Result<bool, DispatchError>

fn can_sudo_approve_spend_proposal(
    bank: OnChainTreasuryID,
    who: &T::AccountId
) -> Result<bool, DispatchError>

fn can_poll_spend_proposal(
    bank: OnChainTreasuryID,
    who: &T::AccountId
) -> Result<bool, DispatchError>

fn can_spend(
    bank: OnChainTreasuryID,
    who: &T::AccountId
) -> Result<bool, DispatchError>

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

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

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> GenerateUniqueID<OnChainTreasuryID> for Module<T>

fn generate_unique_id() -> OnChainTreasuryID

impl<T: Trait> IDIsAvailable<(OnChainTreasuryID, <T as Trait>::SpendId)> for Module<T>

fn id_is_available(id: (OnChainTreasuryID, T::SpendId)) -> bool

impl<T: Trait> IDIsAvailable<OnChainTreasuryID> for Module<T>

fn id_is_available(id: OnChainTreasuryID) -> bool

impl<T: Trait> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

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

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

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

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

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

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

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

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: Trait> OpenBankAccount<<T as Trait>::OrgId, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, <T as Trait>::AccountId> for Module<T>

type BankId = OnChainTreasuryID

fn open_bank_account(
    opener: T::AccountId,
    org: T::OrgId,
    deposit: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance,
    controller: Option<T::AccountId>
) -> Result<Self::BankId, DispatchError>

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

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

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

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

This method tests for !=.

impl<T: Trait> SeededGenerateUniqueID<<T as Trait>::SpendId, OnChainTreasuryID> for Module<T>

fn seeded_generate_unique_id(seed: OnChainTreasuryID) -> T::SpendId

impl<T: Trait> SpendGovernance<OnChainTreasuryID, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, <T as Trait>::AccountId> for Module<T>

type SpendId = BankSpend<OnChainTreasuryID, T::SpendId>

type VoteId = T::VoteId

type SpendState = SpendState<T::VoteId>

fn propose_spend(
    bank_id: OnChainTreasuryID,
    amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance,
    dest: T::AccountId
) -> Result<Self::SpendId, DispatchError>

fn trigger_vote_on_spend_proposal(
    spend_id: Self::SpendId
) -> Result<Self::VoteId, DispatchError>

fn sudo_approve_spend_proposal(spend_id: Self::SpendId) -> DispatchResult

fn poll_spend_proposal(
    spend_id: Self::SpendId
) -> Result<Self::SpendState, DispatchError>

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>