Enum Lifecycle

#[repr(u8)]
pub enum Lifecycle {
    Initial,
    Proposed,
    Accepted,
    Signing,
    Funding,
    Signed,
    Funded,
    Locked,
    Active,
    Reestablishing,
    Shutdown,
    Closing {
        round: usize,
    },
    Aborting,
    Penalize,
    Closed,
}

Channel lifecycle: states of the channel state machine

Variants

Initial

Channel is initialized, communications with the remote peer has not started yet

Proposed

Sent or received open_channel

Accepted

Sent or received accept_channel

Signing

Producing signature for the refund transaction internally

Funding

Local party signed funding tx

Signed

Other peer signed funding tx

Funded

Funding tx is published but not mined

Locked

Funding tx mining confirmed by one peer

Active

Both peers confirmed lock, channel active

Reestablishing

Reestablishing connectivity

Shutdown

Shutdown proposed but not yet accepted

Closing

Shutdown agreed, exchanging closing_signed

Fields

round: usize

Aborting

Non-cooperative unilateral closing initialized from the self

Penalize

Reacting to an uncooperative channel close from remote

Closed

Channel non-operational and closed

Trait Implementations

impl Clone for Lifecycle

fn clone(&self) -> Lifecycle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Lifecycle

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

Formats the value using the given formatter.

impl Default for Lifecycle

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Lifecycle

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Lifecycle

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

Formats the value using the given formatter.

impl Hash for Lifecycle

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Lifecycle

fn cmp(&self, other: &Lifecycle) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Lifecycle

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

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

const 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 PartialOrd for Lifecycle

fn partial_cmp(&self, other: &Lifecycle) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Lifecycle

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for Lifecycle

fn strict_decode<D: Read>(d: D) -> Result<Self, Error>

Decode with the given std::io::Read instance; must either construct an instance or return implementation-specific error type.

fn strict_deserialize(data: impl AsRef<[u8]>) -> Result<Self, Error>

Tries to deserialize byte array into the current type using StrictDecode::strict_decode. If there are some data remains in the buffer once deserialization is completed, fails with Error::DataNotEntirelyConsumed. Use io::Cursor over the buffer and StrictDecode::strict_decode to avoid such failures.

fn strict_file_load(path: impl AsRef<Path>) -> Result<Self, Error>

Reads data from file at path and reconstructs object from it. Fails with Error::DataNotEntirelyConsumed if file contains remaining data after the object reconstruction.

impl StrictEncode for Lifecycle

fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Encode with the given std::io::Write instance; must return result with either amount of bytes encoded – or implementation-specific error type.

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

Serializes data as a byte array using StrictEncode::strict_encode function

fn strict_file_save(&self, path: impl AsRef<Path>) -> Result<usize, Error>

Saves data to a file at a given path. If the file does not exists, attempts to create the file. If the file already exists, it gets truncated.

impl Copy for Lifecycle

impl Eq for Lifecycle

impl StructuralPartialEq for Lifecycle