Struct abstract_sdk::Bank

pub struct Bank<'a, T: TransferInterface> { /* private fields */ }

API for transferring funds to and from the account.

Example

use abstract_sdk::prelude::*;

let bank: Bank<MockModule>  = module.bank(deps.as_ref());

Implementations

impl<'a, T: TransferInterface> Bank<'a, T>

pub fn balances(&self, assets: &[AssetEntry]) -> AbstractSdkResult<Vec<Asset>>

Get the balances of the provided assets.

pub fn balance(&self, asset: &AssetEntry) -> AbstractSdkResult<Asset>

Get the balance of the provided asset.

pub fn transfer<R: Transferable>( &self, funds: Vec<R>, recipient: &Addr ) -> AbstractSdkResult<AccountAction>

Transfer the provided funds from the Account to the recipient.

fn transfer_asset_to_sender(app: MockModule, deps: DepsMut, info: MessageInfo, requested_asset: AnsAsset) -> AbstractSdkResult<Response> {
    let bank = app.bank(deps.as_ref());
    let executor = app.executor(deps.as_ref());    
    let transfer_action = bank.transfer(vec![requested_asset.clone()], &info.sender)?;

    let transfer_msg = executor.execute(vec![transfer_action])?;

    Ok(Response::new()
        .add_message(transfer_msg)
        .add_attribute("recipient", info.sender)
        .add_attribute("asset_sent", requested_asset.to_string()))
}

pub fn deposit<R: Transferable>( &self, funds: Vec<R> ) -> AbstractSdkResult<Vec<CosmosMsg>>

Move funds from the contract into the Account.

pub fn withdraw<R: Transferable>( &self, env: &Env, funds: Vec<R> ) -> AbstractSdkResult<AccountAction>

Withdraw funds from the Account to this contract.

pub fn send<R: Transferable, M: Serialize>( &self, funds: R, recipient: &Addr, message: &M ) -> AbstractSdkResult<AccountAction>

Move cw20 assets from the Account to a recipient with the possibility using the cw20 send/receive hook

Note: Native coins are NOT and will NEVER be supported by this method.

In order to send funds with your message, you need to construct the message yourself

Trait Implementations

impl<'a, T: Clone + TransferInterface> Clone for Bank<'a, T>

fn clone(&self) -> Bank<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.