Enum PacketError

pub enum PacketError {
    Connection(ConnectionError),
    Channel(ChannelError),
    ChannelClosed {
        channel_id: ChannelId,
    },
    InvalidPacketCounterparty {
        port_id: PortId,
        channel_id: ChannelId,
    },
    FrozenClient {
        client_id: ClientId,
    },
    LowPacketHeight {
        chain_height: Height,
        timeout_height: TimeoutHeight,
    },
    LowPacketTimestamp,
    InvalidPacketSequence {
        given_sequence: Sequence,
        next_sequence: Sequence,
    },
    InvalidChannelState {
        channel_id: ChannelId,
        state: State,
    },
    ConnectionNotOpen {
        connection_id: ConnectionId,
    },
    PacketReceiptNotFound {
        sequence: Sequence,
    },
    IncorrectPacketCommitment {
        sequence: Sequence,
    },
    ImplementationSpecific,
    UndefinedConnectionCounterparty {
        connection_id: ConnectionId,
    },
    InvalidProof,
    PacketTimeoutHeightNotReached {
        timeout_height: TimeoutHeight,
        chain_height: Height,
    },
    PacketTimeoutTimestampNotReached {
        timeout_timestamp: Timestamp,
        chain_timestamp: Timestamp,
    },
    AcknowledgementExists {
        sequence: Sequence,
    },
    InvalidAcknowledgement,
    PacketAcknowledgementNotFound {
        sequence: Sequence,
    },
    MissingHeight,
    MissingPacket,
    AppModule {
        description: String,
    },
    RouteNotFound,
    ZeroPacketSequence,
    InvalidTimeoutHeight,
    ZeroPacketData,
    InvalidPacketTimestamp(ParseTimestampError),
    Identifier(IdentifierError),
    MissingNextSendSeq {
        port_id: PortId,
        channel_id: ChannelId,
    },
    ChannelNotFound {
        port_id: PortId,
        channel_id: ChannelId,
    },
    PacketCommitmentNotFound {
        sequence: Sequence,
    },
    MissingNextRecvSeq {
        port_id: PortId,
        channel_id: ChannelId,
    },
    MissingNextAckSeq {
        port_id: PortId,
        channel_id: ChannelId,
    },
}

Variants

Connection(ConnectionError)

connection error: {0}

Channel(ChannelError)

channel error: {0}

ChannelClosed

Channel {channel_id} is Closed

Fields

channel_id: ChannelId

InvalidPacketCounterparty

packet destination port {port_id} and channel {channel_id} doesn’t match the counterparty’s port/channel

Fields

port_id: PortId

channel_id: ChannelId

FrozenClient

Client with id {client_id} is frozen

Fields

client_id: ClientId

LowPacketHeight

Receiving chain block height {chain_height} >= packet timeout height {timeout_height}

Fields

chain_height: Height

timeout_height: TimeoutHeight

LowPacketTimestamp

Receiving chain block timestamp >= packet timeout timestamp

InvalidPacketSequence

Invalid packet sequence {given_sequence} ≠ next send sequence {next_sequence}

Fields

given_sequence: Sequence

next_sequence: Sequence

InvalidChannelState

Channel {channel_id} should not be state {state}

Fields

channel_id: ChannelId

state: State

ConnectionNotOpen

the associated connection {connection_id} is not OPEN

Fields

connection_id: ConnectionId

PacketReceiptNotFound

Receipt for the packet {sequence} not found

Fields

sequence: Sequence

IncorrectPacketCommitment

The stored commitment of the packet {sequence} is incorrect

Fields

sequence: Sequence

ImplementationSpecific

implementation specific error

UndefinedConnectionCounterparty

Undefined counterparty connection for {connection_id}

Fields

connection_id: ConnectionId

InvalidProof

invalid proof: empty proof

PacketTimeoutHeightNotReached

Packet timeout height {timeout_height} > chain height {chain_height}

Fields

timeout_height: TimeoutHeight

chain_height: Height

PacketTimeoutTimestampNotReached

Packet timeout timestamp {timeout_timestamp} > chain timestamp {chain_timestamp}

Fields

timeout_timestamp: Timestamp

chain_timestamp: Timestamp

AcknowledgementExists

Packet acknowledgement exists for the packet with the sequence {sequence}

Fields

sequence: Sequence

InvalidAcknowledgement

Acknowledgment cannot be empty

PacketAcknowledgementNotFound

Acknowledgment for the packet {sequence} not found

Fields

sequence: Sequence

MissingHeight

invalid proof: missing height

MissingPacket

there is no packet in this message

AppModule

application module error: {description}

Fields

description: String

RouteNotFound

route not found

ZeroPacketSequence

packet sequence cannot be 0

InvalidTimeoutHeight

invalid timeout height for the packet

ZeroPacketData

packet data bytes cannot be empty

InvalidPacketTimestamp(ParseTimestampError)

Invalid packet timeout timestamp value error: {0}

Identifier(IdentifierError)

identifier error: {0}

MissingNextSendSeq

Missing sequence number for sending packets on port {port_id} and channel {channel_id}

Fields

port_id: PortId

channel_id: ChannelId

ChannelNotFound

the channel end ({port_id}, {channel_id}) does not exist

Fields

port_id: PortId

channel_id: ChannelId

PacketCommitmentNotFound

Commitment for the packet {sequence} not found

Fields

sequence: Sequence

MissingNextRecvSeq

Missing sequence number for receiving packets on port {port_id} and channel {channel_id}

Fields

port_id: PortId

channel_id: ChannelId

MissingNextAckSeq

Missing sequence number for ack packets on port {port_id} and channel {channel_id}

Fields

port_id: PortId

channel_id: ChannelId

Trait Implementations

impl Debug for PacketError

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

Formats the value using the given formatter.

impl Display for PacketError

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

Formats the value using the given formatter.

impl Error for PacketError

Available on crate feature std only.

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.