Struct abstract_ibc_host::state::Host

pub struct Host<Error: From<StdError> + From<HostError> + 'static, CustomExecMsg: 'static = Empty, CustomInitMsg: 'static = Empty, CustomQueryMsg: 'static = Empty, CustomMigrateMsg: 'static = Empty, Receive: 'static = Empty> {
    pub admin: Admin<'static>,
    pub proxy_address: Option<Addr>,
    /* private fields */
}

The state variables for our host contract.

Fields

admin: Admin<'static>

proxy_address: Option<Addr>

Implementations

impl<Error: From<StdError> + From<HostError>, CustomExecMsg: DeserializeOwned, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

The host contract base implementation.

pub fn handle_packet<RequestError: From<StdError> + From<HostError>>(
    self,
    deps: DepsMut<'_>,
    env: Env,
    packet: IbcPacketReceiveMsg,
    packet_handler: impl FnOnce(DepsMut<'_>, Env, Self, CustomExecMsg) -> Result<IbcReceiveResponse, RequestError>
) -> Result<IbcReceiveResponse, RequestError>

Takes ibc request, matches and executes This fn is the only way to get an Host instance.

pub fn base_execute(
    self,
    deps: DepsMut<'_>,
    _env: Env,
    info: MessageInfo,
    message: BaseExecuteMsg
) -> Result<Response, HostError>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

pub fn receive_balances(
    &self,
    deps: DepsMut<'_>
) -> Result<IbcReceiveResponse, HostError>

pub fn receive_dispatch(
    &self,
    deps: DepsMut<'_>,
    msgs: Vec<CosmosMsg>
) -> Result<IbcReceiveResponse, HostError>

pub fn receive_send_all_back(
    &self,
    deps: DepsMut<'_>,
    env: Env,
    client_proxy_address: String,
    client_chain: String
) -> Result<IbcReceiveResponse, HostError>

processes PacketMsg::SendAllBack variant

pub fn send_all_back(
    &self,
    deps: Deps<'_>,
    env: Env,
    client_proxy_address: String,
    client_chain: String
) -> Result<CosmosMsg, HostError>

construct the msg to send all the assets back

impl<Error: From<StdError> + From<HostError>, CustomExecMsg: Serialize + JsonSchema, CustomInitMsg: Serialize + JsonSchema, CustomQueryMsg: Serialize + JsonSchema, CustomMigrateMsg: Serialize + JsonSchema, ReceiveMsg: Serialize + JsonSchema> Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

pub fn export_schema(out_dir: &Path)

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

pub const fn new(
    name: &'static str,
    version: &'static str,
    chain: &'static str,
    metadata: Option<&'static str>
) -> Self

pub const fn with_replies(
    self,
    reply_handlers: &'static [(u64, ReplyHandlerFn<Self, Error>)]
) -> Self

add reply handler to contract

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

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

pub const fn with_instantiate(
    self,
    instantiate_handler: InstantiateHandlerFn<Self, CustomInitMsg, Error>
) -> Self

pub const fn with_receive(
    self,
    receive_handler: ReceiveHandlerFn<Self, ReceiveMsg, Error>
) -> Self

pub const fn with_execute(
    self,
    execute_handler: ExecuteHandlerFn<Self, CustomExecMsg, Error>
) -> Self

pub const fn with_query(
    self,
    query_handler: QueryHandlerFn<Self, CustomQueryMsg>
) -> Self

Trait Implementations

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> AbstractNameService for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

fn ans_host(&self, deps: Deps<'_>) -> StdResult<AnsHost>

fn name_service<'a>(
    &'a self,
    deps: Deps<'a, Empty>
) -> AbstractNameServiceClient<'a, Self>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg: Serialize + DeserializeOwned + JsonSchema, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg: Serialize + JsonSchema> ExecuteEndpoint for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

The host contract base implementation.

type ExecuteMsg = ExecuteMsg<BaseExecuteMsg, CustomExecMsg, ReceiveMsg>

fn execute(
    self,
    deps: DepsMut<'_>,
    env: Env,
    info: MessageInfo,
    msg: Self::ExecuteMsg
) -> Result<Response, Self::Error>

Entry point for contract execution

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> Handler for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

type Error = Error

type CustomExecMsg = CustomExecMsg

type CustomInitMsg = CustomInitMsg

type CustomQueryMsg = CustomQueryMsg

type CustomMigrateMsg = CustomMigrateMsg

type ReceiveMsg = ReceiveMsg

fn contract(
    &self
) -> &AbstractContract<Self, Self::Error, Self::CustomExecMsg, Self::CustomInitMsg, Self::CustomQueryMsg, Self::CustomMigrateMsg, Self::ReceiveMsg>

fn stored_version(
    &self,
    store: &dyn Storage
) -> Result<ContractVersion, StdError>

fn info(&self) -> (&'static str, &'static str, Option<&'static str>)

fn dependencies(&self) -> &'static [StaticDependency]

fn maybe_execute_handler(
    &self
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::CustomExecMsg) -> Result<Response<Empty>, Self::Error>>

fn execute_handler(
    &self
) -> Result<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::CustomExecMsg) -> Result<Response<Empty>, Self::Error>, StdError>

fn maybe_instantiate_handler(
    &self
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::CustomInitMsg) -> Result<Response<Empty>, Self::Error>>

fn instantiate_handler(
    &self
) -> Result<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::CustomInitMsg) -> Result<Response<Empty>, Self::Error>, StdError>

fn maybe_query_handler(
    &self
) -> Option<fn(_: Deps<'_, Empty>, _: Env, _: &Self, _: Self::CustomQueryMsg) -> Result<Binary, StdError>>

fn query_handler(
    &self
) -> Result<fn(_: Deps<'_, Empty>, _: Env, _: &Self, _: Self::CustomQueryMsg) -> Result<Binary, StdError>, StdError>

fn maybe_migrate_handler(
    &self
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: Self, _: Self::CustomMigrateMsg) -> Result<Response<Empty>, Self::Error>>

fn migrate_handler(
    &self
) -> Result<fn(_: DepsMut<'_, Empty>, _: Env, _: Self, _: Self::CustomMigrateMsg) -> Result<Response<Empty>, Self::Error>, StdError>

fn maybe_receive_handler(
    &self
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::ReceiveMsg) -> Result<Response<Empty>, Self::Error>>

fn receive_handler(
    &self
) -> Result<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: Self::ReceiveMsg) -> Result<Response<Empty>, Self::Error>, StdError>

fn maybe_ibc_callback_handler(
    &self,
    id: &str
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: MessageInfo, _: Self, _: String, _: StdAck) -> Result<Response<Empty>, Self::Error>>

fn maybe_reply_handler(
    &self,
    id: u64
) -> Option<fn(_: DepsMut<'_, Empty>, _: Env, _: Self, _: Reply) -> Result<Response<Empty>, Self::Error>>

fn reply_handler(
    &self,
    id: u64
) -> Result<fn(_: DepsMut<'_, Empty>, _: Env, _: Self, _: Reply) -> Result<Response<Empty>, Self::Error>, StdError>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> Identification for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

fn proxy_address(&self, _deps: Deps<'_>) -> StdResult<Addr>

fn manager_address(&self, _deps: Deps<'_>) -> StdResult<Addr>

fn os_core(&self, _deps: Deps<'_>) -> StdResult<Core>

fn os_id(&self, _deps: Deps<'_>) -> StdResult<u32>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg: Serialize + JsonSchema, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> InstantiateEndpoint for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

type InstantiateMsg = InstantiateMsg<BaseInstantiateMsg, <Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> as Handler>::CustomInitMsg>

Instantiate the api

fn instantiate(
    self,
    deps: DepsMut<'_>,
    env: Env,
    info: MessageInfo,
    msg: Self::InstantiateMsg
) -> Result<Response, Error>

Instantiate the base contract

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg: Serialize + JsonSchema, ReceiveMsg> MigrateEndpoint for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

type MigrateMsg = MigrateMsg<BaseMigrateMsg, CustomMigrateMsg>

fn migrate(
    self,
    deps: DepsMut<'_>,
    env: Env,
    msg: Self::MigrateMsg
) -> Result<Response, Self::Error>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> QueryEndpoint for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

Where we dispatch the queries for the Host These ApiQueryMsg declarations can be found in abstract_sdk::os::common_module::app_msg

type QueryMsg = QueryMsg<BaseQueryMsg, <Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> as Handler>::CustomQueryMsg>

fn query(
    &self,
    deps: Deps<'_>,
    env: Env,
    msg: Self::QueryMsg
) -> Result<Binary, StdError>

impl<Error: From<StdError> + From<HostError>, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg> ReplyEndpoint for Host<Error, CustomExecMsg, CustomInitMsg, CustomQueryMsg, CustomMigrateMsg, ReceiveMsg>

fn reply(
    self,
    deps: DepsMut<'_>,
    env: Env,
    msg: Reply
) -> Result<Response, Self::Error>