Struct ibc::core::channel::types::channel::ChannelEnd

pub struct ChannelEnd {
    pub state: State,
    pub ordering: Order,
    pub remote: Counterparty,
    pub connection_hops: Vec<ConnectionId>,
    pub version: Version,
}

One end of a channel

Fields

state: State

ordering: Order

remote: Counterparty

connection_hops: Vec<ConnectionId>

version: Version

Implementations

impl ChannelEnd

pub fn new( state: State, ordering: Order, remote: Counterparty, connection_hops: Vec<ConnectionId>, version: Version ) -> Result<ChannelEnd, ChannelError>

Creates a new ChannelEnd with performing basic validation on its arguments.

pub fn set_state(&mut self, s: State)

Updates the ChannelEnd to assume a new State ‘s’.

pub fn set_version(&mut self, v: Version)

pub fn set_counterparty_channel_id(&mut self, c: ChannelId)

pub fn is_open(&self) -> bool

Returns true if this ChannelEnd is in state State::Open.

pub fn state(&self) -> &State

pub fn ordering(&self) -> &Order

pub fn counterparty(&self) -> &Counterparty

pub fn connection_hops(&self) -> &Vec<ConnectionId>

pub fn version(&self) -> &Version

pub fn validate_basic(&self) -> Result<(), ChannelError>

pub fn verify_state_matches(&self, expected: &State) -> Result<(), ChannelError>

Checks if the state of this channel end matches the expected state.

pub fn verify_not_closed(&self) -> Result<(), ChannelError>

Checks if the state of this channel end is not closed.

pub fn order_matches(&self, other: &Order) -> bool

👎Deprecated since 0.50.1: Use Eq or match directly on the Order enum instead

Helper function to compare the order of this end with another order.

pub fn connection_hops_matches(&self, other: &Vec<ConnectionId>) -> bool

pub fn verify_counterparty_matches( &self, expected: &Counterparty ) -> Result<(), ChannelError>

Checks if the counterparty of this channel end matches with an expected counterparty.

pub fn verify_connection_hops_length(&self) -> Result<(), ChannelError>

Checks if the connection_hops has a length of expected.

Note: Current IBC version only supports one connection hop.

pub fn version_matches(&self, other: &Version) -> bool

Trait Implementations

impl BorshDeserialize for ChannelEnd

where State: BorshDeserialize, Order: BorshDeserialize, Counterparty: BorshDeserialize, Vec<ConnectionId>: BorshDeserialize, Version: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<ChannelEnd, Error>

where R: Read,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for ChannelEnd

where State: BorshSerialize, Order: BorshSerialize, Counterparty: BorshSerialize, Vec<ConnectionId>: BorshSerialize, Version: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for ChannelEnd

fn clone(&self) -> ChannelEnd

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChannelEnd

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

Formats the value using the given formatter.

impl Decode for ChannelEnd

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ChannelEnd, Error>

where __CodecInputEdqy: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for ChannelEnd

fn deserialize<__D>( __deserializer: __D ) -> Result<ChannelEnd, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ChannelEnd

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

Formats the value using the given formatter.

impl Encode for ChannelEnd

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

where __CodecOutputEdqy: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<ChannelEnd> for Channel

fn from(value: ChannelEnd) -> Channel

Converts to this type from the input type.

impl JsonSchema for ChannelEnd

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for ChannelEnd

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Protobuf<Channel> for ChannelEnd

fn encode<B>(self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode into a buffer in Protobuf format.

fn encode_length_delimited<B>(self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode with a length-delimiter to a buffer in Protobuf format.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode an instance from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode a length-delimited instance from the buffer.

fn encoded_len(self) -> usize

Returns the encoded length of the message without a length delimiter.

fn encode_vec(self) -> Vec<u8>

Encodes into a Protobuf-encoded Vec<u8>.

fn decode_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance from a Vec<u8> (or equivalent).

fn encode_length_delimited_vec(self) -> Vec<u8>

Encode with a length-delimiter to a Vec<u8> Protobuf-encoded message.

fn decode_length_delimited_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance with a length-delimiter from a Vec<u8> or equivalent.

impl Serialize for ChannelEnd

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Channel> for ChannelEnd

type Error = ChannelError

The type returned in the event of a conversion error.

fn try_from( value: Channel ) -> Result<ChannelEnd, <ChannelEnd as TryFrom<Channel>>::Error>

Performs the conversion.

impl TypeInfo for ChannelEnd

type Identity = ChannelEnd

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for ChannelEnd

impl Eq for ChannelEnd

impl StructuralPartialEq for ChannelEnd