Struct 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

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 registry(&self) -> &Registry<Chain>

Registry contract API

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

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

let registry = client.registry();
let vc_module = registry.module(ModuleInfo::from_id_latest("abstract:registry")?)?;
assert_eq!(vc_module.reference, ModuleReference::Native(registry.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 registry 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 module_factory(&self) -> &ModuleFactory<Chain>

Abstract Module Factory contract API

pub fn ibc_client(&self) -> &IbcClient<Chain>

Abstract Ibc Client contract API

The Abstract Ibc Client contract allows users to create and use Interchain Abstract Accounts

pub fn service<M: RegisteredModule + From<Contract<Chain>>>( &self, ) -> Result<Service<Chain, M>, AbstractClientError>

Service contract API

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

Return current block info see BlockInfo.

pub fn fetch_publisher( &self, namespace: Namespace, ) -> Result<Publisher<Chain>, AbstractClientError>

Fetches an existing Abstract Publisher from chain

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

Builder for creating a new Abstract Account.

pub fn sub_account_builder<'a>( &'a self, account: &'a Account<Chain>, ) -> Result<AccountBuilder<'a, Chain>, AbstractClientError>

Builder for creating a new Abstract Account.

pub fn fetch_account<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 fetch_or_build_account<T: Into<AccountSource>, F>( &self, source: T, build_fn: F, ) -> Result<Account<Chain>, AbstractClientError>

where F: for<'a, 'b> FnOnce(&'a mut AccountBuilder<'b, Chain>) -> &'a mut AccountBuilder<'b, Chain>,

Fetches an existing Abstract Account from chain If the Namespace is not claimed, creates an account with the provided account builder

pub fn sender(&self) -> Addr

Address of the sender

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

👎Deprecated since 0.24.2: use fetch_account instead

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 random_account_id(&self) -> Result<u32, AbstractClientError>

Get random local account id sequence(unclaimed) in 2147483648..u32::MAX range

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]

pub fn module_status( &self, module: ModuleInfo, ) -> Result<Option<ModuleStatus>, AbstractClientError>

Retrieves the status of a specified module.

This function checks the status of a module within the registry contract. and returns appropriate Some(ModuleStatus). If the module is not deployed, it returns None.

pub fn call_as(&self, sender: &<Chain as TxHandler>::Sender) -> Self

Clones the Abstract Client with a different sender.

Trait Implementations

impl<Chain: Clone + CwEnv> Clone for AbstractClient<Chain>

fn clone(&self) -> AbstractClient<Chain>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

fn environment(&self) -> Chain

Get the execution environment