Struct Proofs 

pub struct Proofs { /* private fields */ }

Structure comprising proofs in a message. Proofs are typically present in messages for handshake protocols, e.g., ICS3 connection (open) handshake or ICS4 channel (open and close) handshake, as well as for ICS4 packets, timeouts, and acknowledgements.

Implementations

impl Proofs

pub fn new( object_proof: CommitmentProofBytes, client_proof: Option<CommitmentProofBytes>, consensus_proof: Option<ConsensusProof>, host_consensus_state_proof: Option<CommitmentProofBytes>, other_proof: Option<CommitmentProofBytes>, height: Height, ) -> Result<Self, ProofError>

pub fn consensus_proof(&self) -> Option<&ConsensusProof>

Getter for the consensus_proof field of this proof. Intuitively, this is a proof that a client on the source chain stores a consensus state for the destination chain.

pub fn host_consensus_state_proof(&self) -> Option<&CommitmentProofBytes>

Getter for the host_consensus_state_proof field of this proof. This is an optional proof data for host state machines that are unable to introspect their own consensus state.

pub fn height(&self) -> Height

Getter for the height field of this proof (i.e., the consensus height where this proof was created).

pub fn object_proof(&self) -> &CommitmentProofBytes

Getter for the object-specific proof (e.g., proof for connection state or channel state).

pub fn client_proof(&self) -> Option<&CommitmentProofBytes>

Getter for the client_proof.

pub fn other_proof(&self) -> Option<&CommitmentProofBytes>

Getter for the other_proof.

Trait Implementations

impl Clone for Proofs

fn clone(&self) -> Proofs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Proofs

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

Formats the value using the given formatter.

impl PartialEq for Proofs

fn eq(&self, other: &Proofs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Proofs

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Proofs

impl StructuralPartialEq for Proofs