Struct abstract_client::AbstractClient

pub struct AbstractClient<Chain: CwEnv> { /* private fields */ }

Client to interact with Abstract accounts and modules

Implementations

impl<Chain: CwEnv> AbstractClient<Chain>

pub fn builder(chain: Chain) -> AbstractClientBuilder<Chain>

Abstract client builder

pub fn cw20_builder( &self, name: impl Into<String>, symbol: impl Into<String>, decimals: u8 ) -> Cw20Builder<Chain>

Cw20 contract builder

impl<Chain: CwEnv> AbstractClient<Chain>

pub fn new(chain: Chain) -> Result<Self, AbstractClientError>

Get AbstractClient from a chosen environment. Abstract should already be deployed to this environment.

use abstract_client::AbstractClient;

let client = AbstractClient::new(chain)?;

pub fn version_control(&self) -> &VersionControl<Chain>

Version Control contract API

The Version Control contract is a database contract that stores all module-related information.

use abstract_std::objects::{module_reference::ModuleReference, module::ModuleInfo};
// For getting version control address
use cw_orch::prelude::*;

let version_control = client.version_control();
let vc_module = version_control.module(ModuleInfo::from_id_latest("abstract:version-control")?)?;
assert_eq!(vc_module.reference, ModuleReference::Native(version_control.address()?));

pub fn name_service(&self) -> &AnsHost<Chain>

Abstract Name Service contract API

The Abstract Name Service contract is a database contract that stores all asset-related information.

use abstract_client::{AbstractClient, ClientResolve};
use cw_asset::AssetInfo;
use abstract_app::objects::AssetEntry;
// For getting version control address
use cw_orch::prelude::*;

let denom = "test_denom";
let entry = "denom";

let name_service = client.name_service();
let asset_entry = AssetEntry::new(entry);
let asset = asset_entry.resolve(name_service)?;
assert_eq!(asset, AssetInfo::Native(denom.to_owned()));

pub fn block_info(&self) -> Result<BlockInfo, AbstractClientError>

Return current block info see BlockInfo.

pub fn publisher_builder( &self, namespace: Namespace ) -> PublisherBuilder<'_, Chain>

Publisher builder for creating new Publisher Abstract Account To publish any modules your account requires to have claimed a namespace.

pub fn account_builder(&self) -> AccountBuilder<'_, Chain>

Builder for creating a new Abstract Account.

pub fn sender(&self) -> Addr

Address of the sender

pub fn account_from<T: Into<AccountSource>>( &self, source: T ) -> Result<Account<Chain>, AbstractClientError>

Fetch an Account from a given source.

This method is used to retrieve an account from a given source. It will not create a new account if the source is invalid.

Sources that can be used are:

• Namespace: Will retrieve the account from the namespace if it is already claimed.
• AccountId: Will retrieve the account from the account id.
• App Addr: Will retrieve the account from an app that is installed on it.

pub fn query_balance( &self, address: &Addr, denom: impl Into<String> ) -> Result<Uint128, AbstractClientError>

Retrieve denom balance for provided address

pub fn query_balances( &self, address: &Addr ) -> Result<Vec<Coin>, AbstractClientError>

Retrieve balances of all denoms for provided address

pub fn wait_blocks(&self, amount: u64) -> Result<(), AbstractClientError>

Waits for a specified number of blocks.

pub fn wait_seconds(&self, secs: u64) -> Result<(), AbstractClientError>

Waits for a specified number of blocks.

pub fn next_block(&self) -> Result<(), AbstractClientError>

Waits for next block.

pub fn get_last_account( &self ) -> Result<Option<Account<Chain>>, AbstractClientError>

Returns None if no account has been created yet. Note: This only returns accounts that were created with the Client. Any accounts created through the web-app will not be returned.

pub fn next_local_account_id(&self) -> Result<u32, AbstractClientError>

Get next local account id sequence

pub fn module_instantiate2_address<M: RegisteredModule>( &self, account_id: &AccountId ) -> Result<Addr, AbstractClientError>

Get address of instantiate2 module If used for upcoming account this supposed to be used in pair with AbstractClient::next_local_account_id

pub fn module_instantiate2_address_raw( &self, account_id: &AccountId, module_info: ModuleInfo ) -> Result<Addr, AbstractClientError>

Get address of instantiate2 module Raw version of AbstractClient::module_instantiate2_address If used for upcoming account this supposed to be used in pair with AbstractClient::next_local_account_id

impl<Chain: MutCwEnv> AbstractClient<Chain>

pub fn set_balance( &self, address: impl Into<String>, amount: &[Coin] ) -> Result<(), AbstractClientError>

Set balance for an address

pub fn set_balances<'a>( &self, balances: impl IntoIterator<Item = (impl Into<String>, &'a [Coin])> ) -> Result<(), AbstractClientError>

Set on chain balance of addresses

pub fn add_balance( &self, address: impl Into<String>, amount: &[Coin] ) -> Result<(), AbstractClientError>

Add balance for the address

pub fn add_balances<'a>( &self, balances: impl IntoIterator<Item = (impl Into<String>, &'a [Coin])> ) -> Result<(), AbstractClientError>

Add balance for the addresses

Trait Implementations

impl<Chain: CwEnv> Environment<Chain> for AbstractClient<Chain>

fn environment(&self) -> Chain

Get the execution environment