Enum ibc::core::ics04_channel::error::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(ProofError),
    PacketTimeoutHeightNotReached {
        timeout_height: TimeoutHeight,
        chain_height: Height,
    },
    PacketTimeoutTimestampNotReached {
        timeout_timestamp: Timestamp,
        chain_timestamp: Timestamp,
    },
    AcknowledgementExists {
        sequence: Sequence,
    },
    InvalidAcknowledgement,
    PacketAcknowledgementNotFound {
        sequence: Sequence,
    },
    MissingHeight,
    MissingPacket,
    Signer(SignerError),
    AppModule {
        description: String,
    },
    RouteNotFound,
    ZeroPacketSequence,
    InvalidTimeoutHeight,
    ZeroPacketData,
    InvalidPacketTimestamp(ParseTimestampError),
    Identifier(ValidationError),
    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

Fields

channel_id: ChannelId

Channel {channel_id} is Closed

InvalidPacketCounterparty

Fields

port_id: PortId

channel_id: ChannelId

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

FrozenClient

Fields

client_id: ClientId

Client with id {client_id} is frozen

LowPacketHeight

Fields

chain_height: Height

timeout_height: TimeoutHeight

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

LowPacketTimestamp

Receiving chain block timestamp >= packet timeout timestamp

InvalidPacketSequence

Fields

given_sequence: Sequence

next_sequence: Sequence

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

InvalidChannelState

Fields

channel_id: ChannelId

state: State

Channel {channel_id} should not be state {state}

ConnectionNotOpen

Fields

connection_id: ConnectionId

the associated connection {connection_id} is not OPEN

PacketReceiptNotFound

Fields

sequence: Sequence

Receipt for the packet {sequence} not found

IncorrectPacketCommitment

Fields

sequence: Sequence

The stored commitment of the packet {sequence} is incorrect

ImplementationSpecific

implementation specific error

UndefinedConnectionCounterparty

Fields

connection_id: ConnectionId

Undefined counterparty connection for {connection_id}

InvalidProof(ProofError)

invalid proof: {0}

PacketTimeoutHeightNotReached

Fields

timeout_height: TimeoutHeight

chain_height: Height

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

PacketTimeoutTimestampNotReached

Fields

timeout_timestamp: Timestamp

chain_timestamp: Timestamp

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

AcknowledgementExists

Fields

sequence: Sequence

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

InvalidAcknowledgement

Acknowledgment cannot be empty

PacketAcknowledgementNotFound

Fields

sequence: Sequence

Acknowledgment for the packet {sequence} not found

MissingHeight

invalid proof: missing height

MissingPacket

there is no packet in this message

Signer(SignerError)

invalid signer address error: {0}

AppModule

Fields

description: String

application module error: {description}

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(ValidationError)

identifier error: {0}

MissingNextSendSeq

Fields

port_id: PortId

channel_id: ChannelId

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

ChannelNotFound

Fields

port_id: PortId

channel_id: ChannelId

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

PacketCommitmentNotFound

Fields

sequence: Sequence

Commitment for the packet {sequence} not found

MissingNextRecvSeq

Fields

port_id: PortId

channel_id: ChannelId

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

MissingNextAckSeq

Fields

port_id: PortId

channel_id: ChannelId

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

Trait Implementations

impl Debug for PacketError

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

Formats the value using the given formatter.

impl Display for PacketError

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

Formats the value using the given formatter.

impl Error for PacketError

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

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, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl From<PacketError> for ContextError

fn from(err: PacketError) -> ContextError

Converts to this type from the input type.