[−][src]Struct sunshine_bank_onchain::Module

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

Implementations

`impl<T: Trait + 'static> Module<T>`[src]

`pub fn bank_id_nonce() -> OnChainTreasuryID`[src]

`pub fn bank_associated_nonces<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> u32 where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<BankMapID>,` [src]

`pub fn bank_stores<K: EncodeLike<OnChainTreasuryID>>( key: K ) -> Option<BankState<WithdrawalPermissions<T::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>>`[src]

Source of truth for OnChainTreasuryId uniqueness checks WARNING: do not append a prefix because the keyspace is used directly for checking uniqueness TODO: pre-reserve any known ModuleId's that could be accidentally generated that already exist elsewhere

`pub fn deposits<KArg1, KArg2>( k1: KArg1, k2: KArg2 ) -> Option<DepositInfo<T::AccountId, IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>,` [src]

`pub fn spend_reservations<KArg1, KArg2>( k1: KArg1, k2: KArg2 ) -> Option<ReservationInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>,` [src]

`pub fn spend_commitments<KArg1, KArg2>( k1: KArg1, k2: KArg2 ) -> Option<CommitmentInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>> where KArg1: EncodeLike<BankTrackerIdentifier>, KArg2: EncodeLike<WithdrawalPermissions<T::AccountId>>,` [src]

`pub fn internal_transfers<KArg1, KArg2>( k1: KArg1, k2: KArg2 ) -> Option<InternalTransferInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>,` [src]

`pub fn bank_tracker<KArg1, KArg2>( k1: KArg1, k2: KArg2 ) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> where KArg1: EncodeLike<BankTrackerIdentifier>, KArg2: EncodeLike<T::AccountId>,` [src]

Trait Implementations

`impl<T: Trait> BankDepositsAndSpends<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`type Bank = BankState<WithdrawalPermissions<T::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`

`fn make_infallible_deposit_into_free( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> Self::Bank`[src]

`fn fallible_spend_from_reserved( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> Result<Self::Bank, DispatchError>`[src]

`fn fallible_spend_from_free( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> Result<Self::Bank, DispatchError>`[src]

`impl<T: Trait> BankReservations<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Vec<u8>> for Module<T>`[src]

`fn reserve_for_spend( caller: T::AccountId, bank_id: Self::TreasuryId, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, controller: WithdrawalPermissions<T::AccountId> ) -> Result<u32, DispatchError>`[src]

`fn commit_reserved_spend_for_transfer( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, expected_future_owner: WithdrawalPermissions<T::AccountId> ) -> DispatchResult`[src]

`fn unreserve_uncommitted_to_make_free( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> DispatchResult`[src]

`fn unreserve_committed_to_make_free( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> DispatchResult`[src]

`fn transfer_spending_power( caller: T::AccountId, bank_id: Self::TreasuryId, reason: IpfsReference, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, new_controller: WithdrawalPermissions<T::AccountId> ) -> Result<u32, DispatchError>`[src]

`impl<T: Trait> BankSpends<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`fn spend_from_free( from_bank_id: Self::TreasuryId, to: T::AccountId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> DispatchResult`[src]

This method authenticates the spend by checking that the caller input follows the same shape as the bank's controller... => any method that calls this one will need to define local permissions for who can form the request as well as how to constrain the validity of that request based on their ownership/permissions ==> this will be called to liquidate free capital by burning bank controller ownership

`fn spend_from_transfers( from_bank_id: Self::TreasuryId, id: u32, to: T::AccountId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance ) -> Result<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, DispatchError>`[src]

Authenticates the spend within this method based on the identity of to in relation to the transfer_certificate. This is how most (almost all) withdrawals should occur

`impl<T: Trait> BankStorageInfo<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`type DepositInfo = DepositInfo<T::AccountId, IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`

`type ReservationInfo = ReservationInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>`

`type TransferInfo = InternalTransferInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>`

`fn get_deposits_by_account( bank_id: Self::TreasuryId, depositer: T::AccountId ) -> Option<Vec<Self::DepositInfo>>`[src]

`fn total_capital_deposited_by_account( bank_id: Self::TreasuryId, depositer: T::AccountId ) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance`[src]

`fn get_amount_left_in_spend_reservation( bank_id: Self::TreasuryId, reservation_id: u32 ) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`[src]

`fn get_reservations_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId> ) -> Option<Vec<Self::ReservationInfo>>`[src]

`fn total_capital_reserved_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId> ) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance`[src]

`fn get_amount_left_in_approved_transfer( bank_id: Self::TreasuryId, transfer_id: u32 ) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`[src]

`fn get_transfers_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId> ) -> Option<Vec<Self::TransferInfo>>`[src]

`fn total_capital_transferred_to_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId> ) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance`[src]

`impl<T: Trait> Callable<T> for Module<T>`[src]

`type Call = Call<T>`

`impl<T: Trait> CheckBankBalances<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`fn get_bank_store(bank_id: Self::TreasuryId) -> Option<Self::Bank>`[src]

`fn calculate_total_bank_balance_from_balances( bank_id: Self::TreasuryId ) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`[src]

`impl<T: Clone + Trait> Clone for Module<T>`[src]

`fn clone(&self) -> Module<T>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<T: Trait> CommitAndTransfer<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Vec<u8>> for Module<T>`[src]

`fn commit_and_transfer_spending_power( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, new_controller: WithdrawalPermissions<T::AccountId> ) -> Result<u32, DispatchError>`[src]

`impl<T: Copy + Trait> Copy for Module<T>`[src]

`impl<T: Trait> Debug for Module<T> where T: Debug,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result`[src]

`impl<T: Trait> DepositIntoBank<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, Vec<u8>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`fn deposit_into_bank( from: T::AccountId, to_bank_id: Self::TreasuryId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, reason: IpfsReference ) -> Result<u32, DispatchError>`[src]

`impl<T: Eq + Trait> Eq for Module<T>`[src]

`impl<T: Trait> GenerateUniqueID<OnChainTreasuryID> for Module<T>`[src]

`fn generate_unique_id() -> OnChainTreasuryID`[src]

`impl<T: Trait> IDIsAvailable<(OnChainTreasuryID, BankMapID, u32)> for Module<T>`[src]

`fn id_is_available(id: (OnChainTreasuryID, BankMapID, u32)) -> bool`[src]

`impl<T: Trait> IDIsAvailable<OnChainTreasuryID> for Module<T>`[src]

`fn id_is_available(id: OnChainTreasuryID) -> bool`[src]

`impl<T: Trait> ModuleErrorMetadata for Module<T>`[src]

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

`impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>`[src]

`fn offchain_worker(_n: BlockNumber)`[src]

`impl<T: Trait> OnChainBank for Module<T>`[src]

`type OrgId = u32`

`type TreasuryId = OnChainTreasuryID`

`impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>`[src]

`fn on_finalize(_n: BlockNumber)`[src]

`impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>`[src]

`fn on_initialize(_n: BlockNumber) -> u64`[src]

`impl<T: Trait> OnRuntimeUpgrade for Module<T>`[src]

`fn on_runtime_upgrade() -> u64`[src]

`impl<T: Trait> OwnershipProportionCalculations<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Permill> for Module<T>`[src]

`fn calculate_proportion_ownership_for_account( account: T::AccountId, group: WithdrawalPermissions<T::AccountId> ) -> Option<Permill>`[src]

`fn calculate_proportional_amount_for_account( amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, account: T::AccountId, group: WithdrawalPermissions<T::AccountId> ) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>`[src]

`impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>`[src]

`fn eq(&self, other: &Module<T>) -> bool`[src]

`fn ne(&self, other: &Module<T>) -> bool`[src]

`impl<T: Trait> RegisterBankAccount<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`fn register_on_chain_bank_account( registered_org: Self::OrgId, from: T::AccountId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, owner_s: WithdrawalPermissions<T::AccountId> ) -> Result<Self::TreasuryId, DispatchError>`[src]

`fn check_bank_owner(bank_id: Self::TreasuryId, org: Self::OrgId) -> bool`[src]

`impl<T: Trait> SeededGenerateUniqueID<u32, (OnChainTreasuryID, BankMapID)> for Module<T>`[src]

`fn seeded_generate_unique_id(seed: (OnChainTreasuryID, BankMapID)) -> u32`[src]

`impl<T: Trait> StructuralEq for Module<T>`[src]

`impl<T: Trait> StructuralPartialEq for Module<T>`[src]

`impl<T: Trait> TermSheetExit<<T as Trait>::AccountId, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>`[src]

`fn burn_shares_to_exit_bank_ownership( rage_quitter: T::AccountId, bank_id: Self::TreasuryId ) -> Result<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, DispatchError>`[src]

Auto Trait Implementations

`impl<T> RefUnwindSafe for Module<T> where T: RefUnwindSafe,`

`impl<T> Send for Module<T> where T: Send,`

`impl<T> Sync for Module<T> where T: Sync,`

`impl<T> Unpin for Module<T> where T: Unpin,`

`impl<T> UnwindSafe for Module<T> where T: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> CheckedConversion for T`[src]

`fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,` [src]

`fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,` [src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, Outer> IsWrappedBy<Outer> for T where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,` [src]

`fn from_ref(outer: &Outer) -> &T`[src]

Get a reference to the inner from the outer.

`fn from_mut(outer: &mut Outer) -> &mut T`[src]

Get a mutable reference to the inner from the outer.

`impl<T> MaybeDebug for T where T: Debug,`

`impl<T> MaybeRefUnwindSafe for T where T: RefUnwindSafe,`

`impl<T> Member for T where T: 'static + Clone + PartialEq<T> + Eq + Send + Sync + Debug,` [src]

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> SaturatedConversion for T`

`fn saturated_from<T>(t: T) -> Self where Self: UniqueSaturatedFrom<T>,`

`fn saturated_into<T>(self) -> T where Self: UniqueSaturatedInto<T>,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<S, T> UncheckedInto<T> for S where T: UncheckedFrom<S>,` [src]

`fn unchecked_into(self) -> T`[src]

`impl<T, S> UniqueSaturatedInto<T> for S where S: TryInto<T>, T: Bounded,`

`fn unique_saturated_into(self) -> T`

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`fn vzip(self) -> V`

[−][src]Struct sunshine_bank_onchain::Module

Implementations

impl<T: Trait + 'static> Module<T>[src]

pub fn bank_id_nonce() -> OnChainTreasuryID[src]

pub fn bank_associated_nonces<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> u32 where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<BankMapID>, [src]

pub fn bank_stores<K: EncodeLike<OnChainTreasuryID>>( key: K) -> Option<BankState<WithdrawalPermissions<T::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>>[src]

pub fn deposits<KArg1, KArg2>( k1: KArg1, k2: KArg2) -> Option<DepositInfo<T::AccountId, IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>, [src]

pub fn spend_reservations<KArg1, KArg2>( k1: KArg1, k2: KArg2) -> Option<ReservationInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>, [src]

pub fn spend_commitments<KArg1, KArg2>( k1: KArg1, k2: KArg2) -> Option<CommitmentInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>> where KArg1: EncodeLike<BankTrackerIdentifier>, KArg2: EncodeLike<WithdrawalPermissions<T::AccountId>>, [src]

pub fn internal_transfers<KArg1, KArg2>( k1: KArg1, k2: KArg2) -> Option<InternalTransferInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>> where KArg1: EncodeLike<OnChainTreasuryID>, KArg2: EncodeLike<u32>, [src]

pub fn bank_tracker<KArg1, KArg2>( k1: KArg1, k2: KArg2) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> where KArg1: EncodeLike<BankTrackerIdentifier>, KArg2: EncodeLike<T::AccountId>, [src]

Trait Implementations

impl<T: Trait> BankDepositsAndSpends<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]

type Bank = BankState<WithdrawalPermissions<T::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>

fn make_infallible_deposit_into_free( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> Self::Bank[src]

fn fallible_spend_from_reserved( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> Result<Self::Bank, DispatchError>[src]

fn fallible_spend_from_free( bank: Self::Bank, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> Result<Self::Bank, DispatchError>[src]

impl<T: Trait> BankReservations<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Vec<u8>> for Module<T>[src]

fn reserve_for_spend( caller: T::AccountId, bank_id: Self::TreasuryId, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, controller: WithdrawalPermissions<T::AccountId>) -> Result<u32, DispatchError>[src]

fn commit_reserved_spend_for_transfer( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, expected_future_owner: WithdrawalPermissions<T::AccountId>) -> DispatchResult[src]

fn unreserve_uncommitted_to_make_free( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> DispatchResult[src]

fn unreserve_committed_to_make_free( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> DispatchResult[src]

fn transfer_spending_power( caller: T::AccountId, bank_id: Self::TreasuryId, reason: IpfsReference, reservation_id: u32, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, new_controller: WithdrawalPermissions<T::AccountId>) -> Result<u32, DispatchError>[src]

impl<T: Trait> BankSpends<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]

fn spend_from_free( from_bank_id: Self::TreasuryId, to: T::AccountId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> DispatchResult[src]

fn spend_from_transfers( from_bank_id: Self::TreasuryId, id: u32, to: T::AccountId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance) -> Result<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, DispatchError>[src]

impl<T: Trait> BankStorageInfo<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]

type DepositInfo = DepositInfo<T::AccountId, IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>

type ReservationInfo = ReservationInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>

type TransferInfo = InternalTransferInfo<IpfsReference, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, WithdrawalPermissions<T::AccountId>>

fn get_deposits_by_account( bank_id: Self::TreasuryId, depositer: T::AccountId) -> Option<Vec<Self::DepositInfo>>[src]

fn total_capital_deposited_by_account( bank_id: Self::TreasuryId, depositer: T::AccountId) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance[src]

fn get_amount_left_in_spend_reservation( bank_id: Self::TreasuryId, reservation_id: u32) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>[src]

fn get_reservations_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId>) -> Option<Vec<Self::ReservationInfo>>[src]

fn total_capital_reserved_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId>) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance[src]

fn get_amount_left_in_approved_transfer( bank_id: Self::TreasuryId, transfer_id: u32) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>[src]

fn get_transfers_for_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId>) -> Option<Vec<Self::TransferInfo>>[src]

fn total_capital_transferred_to_governance_config( bank_id: Self::TreasuryId, invoker: WithdrawalPermissions<T::AccountId>) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance[src]

impl<T: Trait> Callable<T> for Module<T>[src]

type Call = Call<T>

impl<T: Trait> CheckBankBalances<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]

fn get_bank_store(bank_id: Self::TreasuryId) -> Option<Self::Bank>[src]

fn calculate_total_bank_balance_from_balances( bank_id: Self::TreasuryId) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>[src]

impl<T: Clone + Trait> Clone for Module<T>[src]

fn clone(&self) -> Module<T>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<T: Trait> CommitAndTransfer<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Vec<u8>> for Module<T>[src]

fn commit_and_transfer_spending_power( caller: T::AccountId, bank_id: Self::TreasuryId, reservation_id: u32, reason: IpfsReference, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, new_controller: WithdrawalPermissions<T::AccountId>) -> Result<u32, DispatchError>[src]

impl<T: Copy + Trait> Copy for Module<T>[src]

impl<T: Trait> Debug for Module<T> where T: Debug, [src]

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

impl<T: Trait> DepositIntoBank<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, Vec<u8>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]

fn deposit_into_bank( from: T::AccountId, to_bank_id: Self::TreasuryId, amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, reason: IpfsReference) -> Result<u32, DispatchError>[src]

impl<T: Eq + Trait> Eq for Module<T>[src]

impl<T: Trait> GenerateUniqueID<OnChainTreasuryID> for Module<T>[src]

fn generate_unique_id() -> OnChainTreasuryID[src]

impl<T: Trait> IDIsAvailable<(OnChainTreasuryID, BankMapID, u32)> for Module<T>[src]

fn id_is_available(id: (OnChainTreasuryID, BankMapID, u32)) -> bool[src]

impl<T: Trait> IDIsAvailable<OnChainTreasuryID> for Module<T>[src]

fn id_is_available(id: OnChainTreasuryID) -> bool[src]

impl<T: Trait> ModuleErrorMetadata for Module<T>[src]

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

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>[src]

fn offchain_worker(_n: BlockNumber)[src]

impl<T: Trait> OnChainBank for Module<T>[src]

type OrgId = u32

type TreasuryId = OnChainTreasuryID

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>[src]

fn on_finalize(_n: BlockNumber)[src]

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>[src]

fn on_initialize(_n: BlockNumber) -> u64[src]

impl<T: Trait> OnRuntimeUpgrade for Module<T>[src]

fn on_runtime_upgrade() -> u64[src]

impl<T: Trait> OwnershipProportionCalculations<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, Permill> for Module<T>[src]

fn calculate_proportion_ownership_for_account( account: T::AccountId, group: WithdrawalPermissions<T::AccountId>) -> Option<Permill>[src]

fn calculate_proportional_amount_for_account( amount: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance, account: T::AccountId, group: WithdrawalPermissions<T::AccountId>) -> Option<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance>[src]

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>[src]

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

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

impl<T: Trait> RegisterBankAccount<<T as Trait>::AccountId, WithdrawalPermissions<<T as Trait>::AccountId>, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>[src]