Trait ibc_test_framework::prelude::ChainHandle

source · [−]
pub trait ChainHandle: 'static + Clone + Send + Sync + Serialize + Debug {

Show 48 methods    fn new(chain_id: ChainId, sender: Sender<ChainRequest>) -> Self;
    fn id(&self) -> ChainId;
    fn shutdown(&self) -> Result<(), Error>;
    fn health_check(&self) -> Result<HealthCheck, Error>;
    fn subscribe(
        &self
    ) -> Result<Receiver<Arc<Result<EventBatch, Error>>>, Error>;
    fn send_messages_and_wait_commit(
        &self, 
        tracked_msgs: TrackedMsgs
    ) -> Result<Vec<IbcEvent, Global>, Error>;
    fn send_messages_and_wait_check_tx(
        &self, 
        tracked_msgs: TrackedMsgs
    ) -> Result<Vec<Response, Global>, Error>;
    fn get_signer(&self) -> Result<Signer, Error>;
    fn config(&self) -> Result<ChainConfig, Error>;
    fn get_key(&self) -> Result<KeyEntry, Error>;
    fn add_key(&self, key_name: String, key: KeyEntry) -> Result<(), Error>;
    fn ibc_version(&self) -> Result<Option<Version>, Error>;
    fn query_balance(&self) -> Result<Balance, Error>;
    fn query_application_status(&self) -> Result<ChainStatus, Error>;
    fn query_clients(
        &self, 
        request: QueryClientStatesRequest
    ) -> Result<Vec<IdentifiedAnyClientState, Global>, Error>;
    fn query_client_state(
        &self, 
        request: QueryClientStateRequest
    ) -> Result<AnyClientState, Error>;
    fn query_client_connections(
        &self, 
        request: QueryClientConnectionsRequest
    ) -> Result<Vec<ConnectionId, Global>, Error>;
    fn query_consensus_states(
        &self, 
        request: QueryConsensusStatesRequest
    ) -> Result<Vec<AnyConsensusStateWithHeight, Global>, Error>;
    fn query_consensus_state(
        &self, 
        request: QueryConsensusStateRequest
    ) -> Result<AnyConsensusState, Error>;
    fn query_upgraded_client_state(
        &self, 
        request: QueryUpgradedClientStateRequest
    ) -> Result<(AnyClientState, MerkleProof), Error>;
    fn query_upgraded_consensus_state(
        &self, 
        request: QueryUpgradedConsensusStateRequest
    ) -> Result<(AnyConsensusState, MerkleProof), Error>;
    fn query_commitment_prefix(&self) -> Result<CommitmentPrefix, Error>;
    fn query_compatible_versions(&self) -> Result<Vec<Version, Global>, Error>;
    fn query_connection(
        &self, 
        request: QueryConnectionRequest
    ) -> Result<ConnectionEnd, Error>;
    fn query_connections(
        &self, 
        request: QueryConnectionsRequest
    ) -> Result<Vec<IdentifiedConnectionEnd, Global>, Error>;
    fn query_connection_channels(
        &self, 
        request: QueryConnectionChannelsRequest
    ) -> Result<Vec<IdentifiedChannelEnd, Global>, Error>;
    fn query_next_sequence_receive(
        &self, 
        request: QueryNextSequenceReceiveRequest
    ) -> Result<Sequence, Error>;
    fn query_channels(
        &self, 
        request: QueryChannelsRequest
    ) -> Result<Vec<IdentifiedChannelEnd, Global>, Error>;
    fn query_channel(
        &self, 
        request: QueryChannelRequest
    ) -> Result<ChannelEnd, Error>;
    fn query_channel_client_state(
        &self, 
        request: QueryChannelClientStateRequest
    ) -> Result<Option<IdentifiedAnyClientState>, Error>;
    fn proven_client_state(
        &self, 
        client_id: &ClientId, 
        height: Height
    ) -> Result<(AnyClientState, MerkleProof), Error>;
    fn proven_connection(
        &self, 
        connection_id: &ConnectionId, 
        height: Height
    ) -> Result<(ConnectionEnd, MerkleProof), Error>;
    fn proven_client_consensus(
        &self, 
        client_id: &ClientId, 
        consensus_height: Height, 
        height: Height
    ) -> Result<(AnyConsensusState, MerkleProof), Error>;
    fn build_header(
        &self, 
        trusted_height: Height, 
        target_height: Height, 
        client_state: AnyClientState
    ) -> Result<(AnyHeader, Vec<AnyHeader, Global>), Error>;
    fn build_client_state(
        &self, 
        height: Height, 
        settings: ClientSettings
    ) -> Result<AnyClientState, Error>;
    fn build_consensus_state(
        &self, 
        trusted: Height, 
        target: Height, 
        client_state: AnyClientState
    ) -> Result<AnyConsensusState, Error>;
    fn check_misbehaviour(
        &self, 
        update: UpdateClient, 
        client_state: AnyClientState
    ) -> Result<Option<MisbehaviourEvidence>, Error>;
    fn build_connection_proofs_and_client_state(
        &self, 
        message_type: ConnectionMsgType, 
        connection_id: &ConnectionId, 
        client_id: &ClientId, 
        height: Height
    ) -> Result<(Option<AnyClientState>, Proofs), Error>;
    fn build_channel_proofs(
        &self, 
        port_id: &PortId, 
        channel_id: &ChannelId, 
        height: Height
    ) -> Result<Proofs, Error>;
    fn build_packet_proofs(
        &self, 
        packet_type: PacketMsgType, 
        port_id: &PortId, 
        channel_id: &ChannelId, 
        sequence: Sequence, 
        height: Height
    ) -> Result<(Vec<u8, Global>, Proofs), Error>;
    fn query_packet_commitments(
        &self, 
        request: QueryPacketCommitmentsRequest
    ) -> Result<(Vec<Sequence, Global>, Height), Error>;
    fn query_unreceived_packets(
        &self, 
        request: QueryUnreceivedPacketsRequest
    ) -> Result<Vec<Sequence, Global>, Error>;
    fn query_packet_acknowledgements(
        &self, 
        request: QueryPacketAcknowledgementsRequest
    ) -> Result<(Vec<Sequence, Global>, Height), Error>;
    fn query_unreceived_acknowledgement(
        &self, 
        request: QueryUnreceivedAcksRequest
    ) -> Result<Vec<Sequence, Global>, Error>;
    fn query_txs(
        &self, 
        request: QueryTxRequest
    ) -> Result<Vec<IbcEvent, Global>, Error>;
    fn query_blocks(
        &self, 
        request: QueryBlockRequest
    ) -> Result<(Vec<IbcEvent, Global>, Vec<IbcEvent, Global>), Error>;
    fn query_host_consensus_state(
        &self, 
        request: QueryHostConsensusStateRequest
    ) -> Result<AnyConsensusState, Error>;

    fn query_latest_height(&self) -> Result<Height, Error> { ... }

}

Required Methods

Get the ChainId of this chain.

Shutdown the chain runtime.

Perform a health check

Subscribe to the events emitted by the chain.

Send the given msgs to the chain, packaged as one or more transactions, and return the list of events emitted by the chain after the transaction was committed.

Submit messages asynchronously. Does not block waiting on the chain to produce the resulting events. Instead of events, this method returns a set of transaction hashes.

Return the version of the IBC protocol that this chain is running, if known.

Query the balance of the current account for the denom used to pay tx fees.

Constructs a client state at the given height

Constructs a consensus state at the given height

Provided Methods

Implementations on Foreign Types

Constructs a client state at the given height

Constructs a consensus state at the given height

Implementors

Implement ChainHandle for any existential type Handle: ChainHandle. This allows us to tag values for chains that are tagged by position in N-ary chains.