Abstract Client
This crate provides a central AbstractClient
object that facilitates interacting with the Abstract framework. The client exposes two builders, an account_builder
and publisher_builder
that can be used to retrieve and create accounts.
Applications and their dependencies can then be installed on the Account
using the install_app
or install_app_with_dependencies
functions.
Creating an AbstractClient
To get started you will need to create an Abstract Client
. The client is the main entry point for interacting with the Abstract framework.
There are two ways to create a client, depending on the environment.
For a Public Deployment
If you want to interact with a public deployment of Abstract (like a testnet or mainnet) then you can use the Abstract::new
function like below:
use AbstractClient;
use ;
// Specify a network to connect to (e.g. juno testnet, uni-6)
let juno_testnet: Daemon = default
.handle
.chain
.build?;
// Connect to the deployment
let client: = new?;
For a Local Deployment
When working with a local deployment (mock, or local daemon), you will need to deploy Abstract before you can interact with it. To do this you can use the AbstractClient::builder
function which will deploy the infrastructure when the builder is built and return a client.
use *;
use AbstractClient;
let chain = new;
// Build the client, which will deploy the infrastructure
let client: =
builder
// ... Configure builder
.build?;
Ok::
Interacting with the Client
The main function of the client is to construct Account
, Application
and Publisher
objects.
Creating an Account
To create an account you can use the AbstractClient::account_builder
function. This function will return an AccountBuilder
that you can configure to build an Account
. If a claimed namespace is provided to the builder, the builder will return the Account
that owns that namespace. In the other scenarios the builder will create a new account.
Our examples will use the
MockBech32
environment for simplicity. However, the same functions can be used for anyCwEnv
.
use *;
use ;
use ;
let chain = new;
// Construct the client
let client: = builder.build?;
// Build a new account.
let account: = client.account_builder.build?;
// Install an application.
let my_app: =
account.?;
Ok::
See the AccountBuilder
documentation for more information on how to customize an Account.
Creating a Publisher
Creating a Publisher
follows a similar process to creating an account. You can use the AbstractClient::publisher_builder
function to create a PublisherBuilder
that you can configure to build a Publisher
.
However, unlike an Account
a Publisher
must have a namespace. If a namespace is not yet claimed, the builder will create a new account and claim the namespace. Publisher
is simply a wrapper around an Account
.
The Publisher
can then be used to publish modules to the abstract app store, as shown below.
After the App
is published it can be installed on accounts.
use *;
use ;
use ;
let chain = new;
// Construct the client
let client: = builder.build?;
// Build a Publisher
let publisher: = client.publisher_builder
.build?;
publisher.?;
// Install the published app
let app: =
publisher.account.?;
Ok::
Fetching an Account
If you've previously created an Account
and wish to retrieve it, you can use the AbstractClient::account_from
function. This function accepts three different types of input:
Namespace
- If the namespace is claimed, the function will return theAccount
that owns the namespace.AccountId
- If thisAccountId
exists, the function will return theAccount
with thatAccountId
.- App
Addr
- If there's anApp
installed on the account you can provide itsAddr
to retrieve theAccount
that it is installed on.
use *;
use ;
use ;
let chain = new;
// Construct the client
let client: = builder.build?;
let namespace = new?;
// Build a new account.
let account: = client.account_builder.namespace.build?;
// Fetch the account
let fetched_account: = client.account_from?;
Ok::
Client Test Helpers
Additionally the client supports a set of helper functions you can explore here.