Trait ibc_test_framework::prelude::ChainHandle

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

Show 49 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<IbcEventWithHeight, 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, key_name: Option<String>) -> Result<Balance, Error>;
    fn query_denom_trace(&self, hash: String) -> Result<DenomTrace, 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,
        include_proof: IncludeProof
    ) -> Result<(AnyClientState, Option<MerkleProof>), Error>;
    fn query_client_connections(
        &self,
        request: QueryClientConnectionsRequest
    ) -> Result<Vec<ConnectionId, Global>, Error>;
    fn query_consensus_state(
        &self,
        request: QueryConsensusStateRequest,
        include_proof: IncludeProof
    ) -> Result<(AnyConsensusState, Option<MerkleProof>), Error>;
    fn query_consensus_states(
        &self,
        request: QueryConsensusStatesRequest
    ) -> Result<Vec<AnyConsensusStateWithHeight, Global>, 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,
        include_proof: IncludeProof
    ) -> Result<(ConnectionEnd, Option<MerkleProof>), 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,
        include_proof: IncludeProof
    ) -> Result<(Sequence, Option<MerkleProof>), Error>;
    fn query_channels(
        &self,
        request: QueryChannelsRequest
    ) -> Result<Vec<IdentifiedChannelEnd, Global>, Error>;
    fn query_channel(
        &self,
        request: QueryChannelRequest,
        include_proof: IncludeProof
    ) -> Result<(ChannelEnd, Option<MerkleProof>), Error>;
    fn query_channel_client_state(
        &self,
        request: QueryChannelClientStateRequest
    ) -> Result<Option<IdentifiedAnyClientState>, 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<Proofs, Error>;
    fn query_packet_commitment(
        &self,
        request: QueryPacketCommitmentRequest,
        include_proof: IncludeProof
    ) -> Result<(Vec<u8, Global>, Option<MerkleProof>), Error>;
    fn query_packet_commitments(
        &self,
        request: QueryPacketCommitmentsRequest
    ) -> Result<(Vec<Sequence, Global>, Height), Error>;
    fn query_packet_receipt(
        &self,
        request: QueryPacketReceiptRequest,
        include_proof: IncludeProof
    ) -> Result<(Vec<u8, Global>, Option<MerkleProof>), Error>;
    fn query_unreceived_packets(
        &self,
        request: QueryUnreceivedPacketsRequest
    ) -> Result<Vec<Sequence, Global>, Error>;
    fn query_packet_acknowledgement(
        &self,
        request: QueryPacketAcknowledgementRequest,
        include_proof: IncludeProof
    ) -> Result<(Vec<u8, Global>, Option<MerkleProof>), Error>;
    fn query_packet_acknowledgements(
        &self,
        request: QueryPacketAcknowledgementsRequest
    ) -> Result<(Vec<Sequence, Global>, Height), Error>;
    fn query_unreceived_acknowledgements(
        &self,
        request: QueryUnreceivedAcksRequest
    ) -> Result<Vec<Sequence, Global>, Error>;
    fn query_txs(
        &self,
        request: QueryTxRequest
    ) -> Result<Vec<IbcEventWithHeight, 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 given account for the denom used to pay tx fees. If no account is given, behavior must be specified, e.g. retrieve it from configuration file.

Query the denomination trace given a trace hash.

Query the latest height and timestamp the application is at

Performs a query to retrieve the state of all clients that a chain hosts.

Performs a query to retrieve the state of the specified light client. A proof can optionally be returned along with the result.

Performs a query to retrieve the identifiers of all connections.

Performs a query to retrieve the consensus state for a specified height consensus_height that the specified light client stores.

Performs a query to retrieve all the consensus states that the specified light client stores.

Performs a query to retrieve the connection associated with a given connection identifier. A proof can optionally be returned along with the result.

Performs a query to retrieve the identifiers of all connections.

Performs a query to retrieve all channels associated with a connection.

Performs a query to retrieve nextSequenceRecv stored at path path::SeqRecvsPath as defined in ICS-4. A proof can optionally be returned along with the result.

Performs a query to retrieve all the channels of a chain.

Performs a query to retrieve the channel associated with a given channel identifier. A proof can optionally be returned along with the result.

Performs a query to retrieve the client state for the channel associated with a given channel identifier.

Constructs a client state at the given height

Constructs a consensus state at the given height

Performs a query to retrieve a stored packet commitment hash, stored on the chain at path path::CommitmentsPath. A proof can optionally be returned along with the result.

Performs a query to retrieve all the packet commitments hashes associated with a channel. Returns the corresponding packet sequence numbers and the height at which they were retrieved.

Performs a query to retrieve a given packet receipt, stored on the chain at path path::CommitmentsPath. A proof can optionally be returned along with the result.

Performs a query about which IBC packets in the specified list has not been received. Returns the sequence numbers of the packets that were not received.

For example, given a request with the sequence numbers [5,6,7,8], a response of [7,8] would indicate that packets 5 & 6 were received, while packets 7, 8 were not.

Performs a query to retrieve a stored packet acknowledgement hash, stored on the chain at path path::AcksPath. A proof can optionally be returned along with the result.

Performs a query to retrieve all the packet acknowledgements associated with a channel. Returns the corresponding packet sequence numbers and the height at which they were retrieved.

Performs a query about which IBC packets in the specified list has not been acknowledged. Returns the sequence numbers of the packets that were not acknowledged.

For example, given a request with the sequence numbers [5,6,7,8], a response of [7,8] would indicate that packets 5 & 6 were acknowledged, while packets 7, 8 were not.

Provided Methods

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.