Struct ibc_relayer::connection::Connection

pub struct Connection<ChainA: ChainHandle, ChainB: ChainHandle> {
    pub delay_period: Duration,
    pub a_side: ConnectionSide<ChainA>,
    pub b_side: ConnectionSide<ChainB>,
}

Fields

delay_period: Duration

a_side: ConnectionSide<ChainA>

b_side: ConnectionSide<ChainB>

Implementations

impl<ChainA: ChainHandle, ChainB: ChainHandle> Connection<ChainA, ChainB>

pub fn new(
    b_to_a_client: ForeignClient<ChainA, ChainB>,
    a_to_b_client: ForeignClient<ChainB, ChainA>,
    delay_period: Duration
) -> Result<Self, ConnectionError>

Create a new connection, ensuring that the handshake has succeeded and the two connection ends exist on each side.

pub fn restore_from_event(
    chain: ChainA,
    counterparty_chain: ChainB,
    connection_open_event: IbcEvent
) -> Result<Connection<ChainA, ChainB>, ConnectionError>

pub fn restore_from_state(
    chain: ChainA,
    counterparty_chain: ChainB,
    connection: WorkerConnectionObject,
    height: Height
) -> Result<(Connection<ChainA, ChainB>, State), ConnectionError>

Recreates a ‘Connection’ object from the worker’s object built from chain state scanning. The connection must exist on chain.

pub fn find(
    a_client: ForeignClient<ChainA, ChainB>,
    b_client: ForeignClient<ChainB, ChainA>,
    conn_end_a: &IdentifiedConnectionEnd
) -> Result<Connection<ChainA, ChainB>, ConnectionError>

pub fn src_chain(&self) -> ChainA

pub fn dst_chain(&self) -> ChainB

pub fn src_client_id(&self) -> &ClientId

pub fn dst_client_id(&self) -> &ClientId

pub fn src_connection_id(&self) -> Option<&ConnectionId>

pub fn dst_connection_id(&self) -> Option<&ConnectionId>

pub fn flipped(&self) -> Connection<ChainB, ChainA>

pub fn counterparty_state(&self) -> Result<State, ConnectionError>

pub fn handshake_step(
    &mut self,
    state: State
) -> Result<(Option<IbcEvent>, Next), ConnectionError>

pub fn step_state(&mut self, state: State, index: u64) -> RetryResult<Next, u64>

pub fn step_event(
    &mut self,
    event: IbcEvent,
    index: u64
) -> RetryResult<Next, u64>

pub fn build_update_client_on_src(
    &self,
    height: Height
) -> Result<Vec<Any>, ConnectionError>

pub fn build_update_client_on_dst(
    &self,
    height: Height
) -> Result<Vec<Any>, ConnectionError>

pub fn build_conn_init(&self) -> Result<Vec<Any>, ConnectionError>

pub fn build_conn_init_and_send(&self) -> Result<IbcEvent, ConnectionError>

pub fn build_conn_try(&self) -> Result<Vec<Any>, ConnectionError>

Attempts to build a MsgConnOpenTry.

pub fn build_conn_try_and_send(&self) -> Result<IbcEvent, ConnectionError>

pub fn build_conn_ack(&self) -> Result<Vec<Any>, ConnectionError>

Attempts to build a MsgConnOpenAck.

pub fn build_conn_ack_and_send(&self) -> Result<IbcEvent, ConnectionError>

pub fn build_conn_confirm(&self) -> Result<Vec<Any>, ConnectionError>

Attempts to build a MsgConnOpenConfirm.

pub fn build_conn_confirm_and_send(&self) -> Result<IbcEvent, ConnectionError>

pub fn map_chain<ChainC: ChainHandle, ChainD: ChainHandle>(
    self,
    mapper_a: impl Fn(ChainA) -> ChainC,
    mapper_b: impl Fn(ChainB) -> ChainD
) -> Connection<ChainC, ChainD>

Trait Implementations

impl<ChainA: Clone + ChainHandle, ChainB: Clone + ChainHandle> Clone for Connection<ChainA, ChainB>

fn clone(&self) -> Connection<ChainA, ChainB>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ChainA: Debug + ChainHandle, ChainB: Debug + ChainHandle> Debug for Connection<ChainA, ChainB>

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

Formats the value using the given formatter.

impl<ChainA: ChainHandle, ChainB: ChainHandle> Serialize for Connection<ChainA, ChainB> where
    ChainA: Serialize,
    ChainB: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.