Struct abstract_api::state::ApiContract

pub struct ApiContract<'a, T: Serialize + DeserializeOwned> {
    pub traders: Map<'a, Addr, HashSet<Addr>>,
    pub base_state: Item<'a, ApiState>,
    pub version: Item<'a, ContractVersion>,
    pub dependencies: &'static [&'static str],
    pub target_os: Option<Core>,
    /* private fields */
}

The state variables for our ApiContract.

Fields

traders: Map<'a, Addr, HashSet<Addr>>

base_state: Item<'a, ApiState>

version: Item<'a, ContractVersion>

Stores the API version

dependencies: &'static [&'static str]

target_os: Option<Core>

Implementations

impl<'a, T: Serialize + DeserializeOwned> ApiContract<'a, T>

The api-contract base implementation.

pub fn handle_request<RequestError: From<StdError> + From<ApiError>>(
    self,
    deps: DepsMut<'_>,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg<T>,
    request_handler: impl FnOnce(DepsMut<'_>, Env, MessageInfo, ApiContract<'_, T>, T) -> Result<Response, RequestError>
) -> Result<Response, RequestError>

Takes request, sets destination and executes request handler This fn is the only way to get an ApiContract instance which ensures the destination address is set correctly.

pub fn execute(
    &mut self,
    deps: DepsMut<'_>,
    env: Env,
    info: MessageInfo,
    message: BaseExecuteMsg
) -> ApiResult

impl<'a, T: Serialize + DeserializeOwned> ApiContract<'a, T>

pub fn instantiate(
    deps: DepsMut<'_>,
    _env: Env,
    _info: MessageInfo,
    msg: BaseInstantiateMsg,
    module_name: &str,
    module_version: &str,
    _api_dependencies: Vec<String>
) -> StdResult<Self>

Instantiate the API

impl<'a, T: Serialize + DeserializeOwned> ApiContract<'a, T>

Where we dispatch the queries for the ApiContract These ApiQueryMsg declarations can be found in abstract_os::common_module::add_on_msg

pub fn handle_query<Q: Serialize + DeserializeOwned, QueryError: From<StdError> + From<ApiError>>(
    &self,
    deps: Deps<'_>,
    env: Env,
    msg: QueryMsg<Q>,
    custom_query_handler: Option<fn(_: Deps<'_>, _: Env, _: Q) -> Result<Binary, QueryError>>
) -> Result<Binary, QueryError>

impl<'a, T: Serialize + DeserializeOwned> ApiContract<'a, T>

Constructor

pub const fn new(dependencies: &'static [&'static str]) -> Self

pub fn state(&self, store: &dyn Storage) -> StdResult<ApiState>

pub fn version(&self, store: &dyn Storage) -> StdResult<ContractVersion>

pub fn target(&self) -> Result<&Addr, ApiError>

Trait Implementations

impl<'a, T: Serialize + DeserializeOwned> Default for ApiContract<'a, T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Serialize + DeserializeOwned> Dependency for ApiContract<'_, T>

Implement the dependency functions for an API contract

fn dependency_address(
    &self,
    deps: Deps<'_>,
    dependency_name: &str
) -> StdResult<Addr>

fn call_api_dependency<E: Serialize>(
    &self,
    deps: Deps<'_>,
    dependency_name: &str,
    request_msg: &E,
    funds: Vec<Coin>
) -> StdResult<CosmosMsg>

impl<T: Serialize + DeserializeOwned> MemoryOperation for ApiContract<'_, T>

fn load_memory(&self, store: &dyn Storage) -> StdResult<Memory>

Load the Memory object

fn resolve<T>(
    &self,
    deps: Deps<'_, Empty>,
    memory_entry: &T
) -> Result<<T as Resolve>::Output, StdError>where
    T: Resolve,

Resolve a query on the memory contract

impl<T: Serialize + DeserializeOwned> OsExecute for ApiContract<'_, T>

Execute a set of CosmosMsgs on the proxy contract of an OS.

type Err = ApiError

fn os_execute(
    &self,
    _deps: Deps<'_>,
    msgs: Vec<CosmosMsg>
) -> Result<Response, Self::Err>