Struct abstract_api::state::ApiContract

pub struct ApiContract<'a, Request: Serialize + DeserializeOwned, Error: From<StdError> + From<ApiError>, Receive: Serialize + DeserializeOwned = Empty> {
    pub traders: Map<'a, Addr, HashSet<Addr>>,
    pub base_state: Item<'a, ApiState>,
    pub version: Item<'a, ContractVersion>,
    pub target_os: Option<Core>,
    pub dependencies: &'static [&'static str],
    /* 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

target_os: Option<Core>

dependencies: &'static [&'static str]

Implementations

impl<'a, T: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> ApiContract<'a, T, E>

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, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> ApiContract<'a, T, E, C>

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, R: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> ApiContract<'a, T, E, R>

Constructor

pub const fn new() -> Self

pub const fn with_ibc_callbacks(
    self,
    callbacks: &'a [(&'static str, IbcCallbackHandlerFn<Self, E>)]
) -> Self

add IBC callback handler to contract

pub const fn with_receive(
    self,
    receive_handler: ReceiveHandlerFn<Self, R, E>
) -> Self

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

add dependencies to the contract

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, E: From<StdError> + From<ApiError>, C: Serialize + DeserializeOwned> AbstractExecute for ApiContract<'a, T, E, C>

type RequestMsg = T

type ExecuteMsg<P> = ExecuteMsg<T, C>

type ContractError = E

fn execute(
    self,
    deps: DepsMut<'_>,
    env: Env,
    info: MessageInfo,
    msg: Self::ExecuteMsg<Self::RequestMsg>,
    request_handler: impl FnOnce(DepsMut<'_>, Env, MessageInfo, Self, T) -> Result<Response, E>
) -> Result<Response, Self::ContractError>

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.

impl<'a, T: Serialize + DeserializeOwned, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> Default for ApiContract<'a, T, E, C>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Serialize + DeserializeOwned, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> Dependency for ApiContract<'_, T, E, C>

Implement the dependency functions for an API contract

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

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

impl<'a, T: Serialize + DeserializeOwned, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> IbcCallbackEndpoint for ApiContract<'a, T, E, C>

type ContractError = E

fn callback_handler(
    &self,
    id: &str
) -> Option<IbcCallbackHandlerFn<Self, Self::ContractError>>

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.

fn handle_ibc_callback(
    self,
    deps: DepsMut<'_, Empty>,
    env: Env,
    info: MessageInfo,
    msg: IbcResponseMsg
) -> Result<Response<Empty>, Self::ContractError>

impl<T: Serialize + DeserializeOwned, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> MemoryOperation for ApiContract<'_, T, E, C>

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, C: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>> OsExecute for ApiContract<'_, T, E, C>

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>

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

impl<'a, T: Serialize + DeserializeOwned, E: From<StdError> + From<ApiError>, R: Serialize + DeserializeOwned> ReceiveEndpoint for ApiContract<'a, T, E, R>

type ContractError = E

type ReceiveMsg = R

fn receive_handler(
    &self
) -> Option<ReceiveHandlerFn<Self, Self::ReceiveMsg, Self::ContractError>>

fn handle_receive(
    self,
    deps: DepsMut<'_, Empty>,
    env: Env,
    info: MessageInfo,
    msg: Self::ReceiveMsg
) -> Result<Response<Empty>, Self::ContractError>