Struct abstract_interface::Abstract

pub struct Abstract<Chain: CwEnv> {
    pub ans_host: AnsHost<Chain>,
    pub version_control: VersionControl<Chain>,
    pub account_factory: AccountFactory<Chain>,
    pub module_factory: ModuleFactory<Chain>,
    pub ibc: AbstractIbc<Chain>,
    /* private fields */
}

Fields

ans_host: AnsHost<Chain>

version_control: VersionControl<Chain>

account_factory: AccountFactory<Chain>

module_factory: ModuleFactory<Chain>

ibc: AbstractIbc<Chain>

Implementations

impl<Chain: CwEnv> Abstract<Chain>

pub fn new(chain: Chain) -> Self

pub fn instantiate( &mut self, _chain: &Chain, admin: String ) -> Result<(), AbstractInterfaceError>

pub fn contracts(&self) -> Vec<(&Contract<Chain>, String)>

Trait Implementations

impl<Chain: CwEnv> Deploy<Chain> for Abstract<Chain>

type Error = AbstractInterfaceError

Error type returned by the deploy functions.

type DeployData = String

Data required to deploy the application.

fn store_on(chain: Chain) -> Result<Self, AbstractInterfaceError>

Stores/uploads the application to the chain.

fn deploy_on(chain: Chain, data: String) -> Result<Self, AbstractInterfaceError>

Deploy the application to the chain. This could include instantiating contracts.

fn get_contracts_mut(&mut self) -> Vec<Box<&mut dyn ContractInstance<Chain>>>

Returns all the contracts in this deployment instance Used to set the contract state (addr and code_id) when importing the package.

fn deployed_state_file_path() -> Option<String>

Sets the custom state file path for exporting the state with the package. This function needs to be defined by projects. If the project doesn’t want to give deployment state with their crate, they can return None here.

fn load_from(chain: Chain) -> Result<Self, Self::Error>

Load the application from the chain, assuming it has already been deployed. In order to leverage the deployed state, don’t forget to call Self::set_contracts_state after loading the contract objects

fn multi_network_deploy( networks: Vec<(Chain, Self::DeployData)>, _gas_needed: Option<u64>, after_deploy_action: Option<fn(_: &Self) -> Result<(), Error>> ) -> Result<HashMap<String, Self>, Error>

Deploys the applications on all chains indicated in chains. Arguments :

fn set_contracts_state(&mut self, custom_state: Option<Value>)

Set the default contract state for a contract, so that users can retrieve it in their application when importing the library If a state is provided, it is used for all contracts, otherwise, the state is loaded from the crate’s state file.

fn get_all_deployed_chains() -> Vec<String>

Gets all the chain ids on which the library is deployed on This loads all chains that are registered in the crate-local daemon_state file The state file should have the following format : { “juno”:{ “juno-1”:{ … }, “uni-6”: { } } … } So this function actually looks for the second level of indices in the deployed_state_file