Struct TypedRelayerOps

pub struct TypedRelayerOps<A, B>(/* private fields */)
where
    A: TestHost,
    B: TestHost,
    HostClientState<A>: ClientStateValidation<DefaultIbcStore>,
    HostClientState<B>: ClientStateValidation<DefaultIbcStore>;

Implements IBC relayer functions for a pair of TestHost implementations: A and B. Note that, all the implementations are in one direction: from A to B. This ensures that the variable namings are consistent with the IBC message fields, leading to a less error-prone implementation.

For the functions in the opposite direction, use TypedRelayerOps::<B, A> instead of TypedRelayerOps::<A, B>`.

Implementations

impl<A, B> TypedRelayerOps<A, B>

where A: TestHost, B: TestHost, HostClientState<A>: ClientStateValidation<DefaultIbcStore>, HostClientState<B>: ClientStateValidation<DefaultIbcStore>,

pub fn create_client_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, signer: Signer, ) -> ClientId

Creates a client on A with the state of B. Returns the client identifier on A.

pub fn sync_clock_on_a(ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>)

Advances the block height on A until it catches up with the latest timestamp on B.

pub fn update_client_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, client_id_on_a: ClientId, signer: Signer, )

Updates the client on A with the latest header from B.

pub fn update_client_on_a_with_sync( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, client_id_on_a: ClientId, signer: Signer, )

Updates the client on A with the latest header from B after syncing the timestamps.

Timestamp sync is required, as IBC doesn’t allow client updates from the future beyond max clock drift.

pub fn connection_open_init_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, ) -> ConnectionId

A initiates a connection with the other end on B. Returns the connection identifier on A.

pub fn connection_open_try_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, conn_id_on_a: ConnectionId, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, ) -> ConnectionId

B receives the connection opening attempt by A after A initiates the connection. Returns the connection identifier on B.

pub fn connection_open_ack_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, conn_id_on_a: ConnectionId, conn_id_on_b: ConnectionId, client_id_on_b: ClientId, signer: Signer, )

A receives B’s acknowledgement that B received the connection opening attempt by A. A starts processing the connection on its side.

pub fn connection_open_confirm_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, conn_id_on_a: ConnectionId, conn_id_on_b: ConnectionId, signer: Signer, )

B receives the confirmation from A that the connection creation was successful. B also starts processing the connection on its side.

pub fn create_connection_on_a( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, ) -> (ConnectionId, ConnectionId)

A connection is created by A towards B using the IBC connection handshake protocol. Returns the connection identifiers of A and B.

pub fn channel_open_init_on_a( ctx_a: &mut TestContext<A>, conn_id_on_a: ConnectionId, port_id_on_a: PortId, port_id_on_b: PortId, signer: Signer, ) -> ChannelId

A initiates a channel with port identifier with the other end on B. Returns the channel identifier of A.

pub fn channel_open_try_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, conn_id_on_b: ConnectionId, chan_id_on_a: ChannelId, port_id_on_a: PortId, signer: Signer, ) -> ChannelId

B receives the channel opening attempt by A after A initiates the channel. Returns the channel identifier of B.

pub fn channel_open_ack_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, chan_id_on_a: ChannelId, port_id_on_a: PortId, chan_id_on_b: ChannelId, port_id_on_b: PortId, signer: Signer, )

A receives B’s acknowledgement that B received the channel opening attempt by A. A starts processing the channel on its side.

pub fn channel_open_confirm_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, chan_id_on_a: ChannelId, chan_id_on_b: ChannelId, port_id_on_b: PortId, signer: Signer, )

B receives the confirmation from A that the channel creation was successful. B also starts processing the channel on its side.

pub fn channel_close_init_on_a( ctx_a: &mut TestContext<A>, chan_id_on_a: ChannelId, port_id_on_a: PortId, signer: Signer, )

A initiates the channel closing, with the other end on B. A stops processing the channel.

pub fn channel_close_confirm_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, chan_id_on_b: ChannelId, port_id_on_b: PortId, signer: Signer, )

B receives the channel closing attempt by A after A initiates the channel closing. B also stops processing the channel.

pub fn create_channel_on_a( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, client_id_on_a: ClientId, conn_id_on_a: ConnectionId, port_id_on_a: PortId, client_id_on_b: ClientId, conn_id_on_b: ConnectionId, port_id_on_b: PortId, signer: Signer, ) -> (ChannelId, ChannelId)

A channel is created by A towards B using the IBC channel handshake protocol. Returns the channel identifiers of A and B.

pub fn close_channel_on_a( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, client_id_on_a: ClientId, chan_id_on_a: ChannelId, port_id_on_a: PortId, client_id_on_b: ClientId, chan_id_on_b: ChannelId, port_id_on_b: PortId, signer: Signer, )

A channel is closed by A towards B using the IBC channel handshake protocol.

pub fn packet_recv_on_b( ctx_b: &mut TestContext<B>, ctx_a: &TestContext<A>, packet: Packet, signer: Signer, ) -> Acknowledgement

B receives a packet from an IBC module on A. Returns B’s acknowledgement of receipt.

pub fn packet_ack_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, packet: Packet, acknowledgement: Acknowledgement, signer: Signer, )

A receives the acknowledgement from B that B received the packet from A.

pub fn packet_timeout_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, packet: Packet, signer: Signer, )

A receives the timeout packet from B. That is, B has not received the packet from A within the timeout period.

pub fn packet_timeout_on_close_on_a( ctx_a: &mut TestContext<A>, ctx_b: &TestContext<B>, packet: Packet, chan_id_on_b: ChannelId, port_id_on_b: PortId, signer: Signer, )

A receives the timeout packet from B after closing the channel. That is, B has not received the packet from A because the channel is closed.

pub fn submit_packet_on_b( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, packet: Packet, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, )

Sends a packet from an IBC application on A to B using the IBC packet relay protocol.

pub fn timeout_packet_from_a( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, packet: Packet, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, )

Times out a packet from an IBC application on A to B after waiting timeout period.

pub fn timeout_packet_from_a_on_channel_close( ctx_a: &mut TestContext<A>, ctx_b: &mut TestContext<B>, packet: Packet, client_id_on_a: ClientId, client_id_on_b: ClientId, signer: Signer, )

Times out a packet from an IBC application on A to B after closing the channel.

Trait Implementations

impl<A, B> Debug for TypedRelayerOps<A, B>

where A: TestHost + Debug, B: TestHost + Debug, HostClientState<A>: ClientStateValidation<DefaultIbcStore>, HostClientState<B>: ClientStateValidation<DefaultIbcStore>,

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

Formats the value using the given formatter.

impl<A, B> Default for TypedRelayerOps<A, B>

where A: TestHost + Default, B: TestHost + Default, HostClientState<A>: ClientStateValidation<DefaultIbcStore>, HostClientState<B>: ClientStateValidation<DefaultIbcStore>,

fn default() -> TypedRelayerOps<A, B>

Returns the “default value” for a type.