Struct ibc_proto::ibc::applications::fee::v1::msg_client::MsgClient

pub struct MsgClient<T> { /* private fields */ }

Msg defines the ICS29 Msg service.

Implementations

impl MsgClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>where
    D: TryInto<Endpoint>,
    D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> MsgClient<T>where
    T: GrpcService<BoxBody>,
    T::Error: Into<StdError>,
    T::ResponseBody: Body<Data = Bytes> + Send + 'static,
    <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>(
    inner: T,
    interceptor: F
) -> MsgClient<InterceptedService<T, F>>where
    F: Interceptor,
    T::ResponseBody: Default,
    T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>,
    <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub async fn register_payee(
    &mut self,
    request: impl IntoRequest<MsgRegisterPayee>
) -> Result<Response<MsgRegisterPayeeResponse>, Status>

RegisterPayee defines a rpc handler method for MsgRegisterPayee RegisterPayee is called by the relayer on each channelEnd and allows them to set an optional payee to which reverse and timeout relayer packet fees will be paid out. The payee should be registered on the source chain from which packets originate as this is where fee distribution takes place. This function may be called more than once by a relayer, in which case, the latest payee is always used.

pub async fn register_counterparty_payee(
    &mut self,
    request: impl IntoRequest<MsgRegisterCounterpartyPayee>
) -> Result<Response<MsgRegisterCounterpartyPayeeResponse>, Status>

RegisterCounterpartyPayee defines a rpc handler method for MsgRegisterCounterpartyPayee RegisterCounterpartyPayee is called by the relayer on each channelEnd and allows them to specify the counterparty payee address before relaying. This ensures they will be properly compensated for forward relaying since the destination chain must include the registered counterparty payee address in the acknowledgement. This function may be called more than once by a relayer, in which case, the latest counterparty payee address is always used.

pub async fn pay_packet_fee(
    &mut self,
    request: impl IntoRequest<MsgPayPacketFee>
) -> Result<Response<MsgPayPacketFeeResponse>, Status>

PayPacketFee defines a rpc handler method for MsgPayPacketFee PayPacketFee is an open callback that may be called by any module/user that wishes to escrow funds in order to incentivize the relaying of the packet at the next sequence NOTE: This method is intended to be used within a multi msg transaction, where the subsequent msg that follows initiates the lifecycle of the incentivized packet

pub async fn pay_packet_fee_async(
    &mut self,
    request: impl IntoRequest<MsgPayPacketFeeAsync>
) -> Result<Response<MsgPayPacketFeeAsyncResponse>, Status>

PayPacketFeeAsync defines a rpc handler method for MsgPayPacketFeeAsync PayPacketFeeAsync is an open callback that may be called by any module/user that wishes to escrow funds in order to incentivize the relaying of a known packet (i.e. at a particular sequence)

Trait Implementations

impl<T: Clone> Clone for MsgClient<T>

fn clone(&self) -> MsgClient<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for MsgClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.