Struct mutiny_core::redshift::Redshift

pub struct Redshift {

    pub id: [u8; 16],
    pub input_utxo: OutPoint,
    pub status: RedshiftStatus,
    pub sending_node: PublicKey,
    pub recipient: RedshiftRecipient,
    pub receiving_node: Option<PublicKey>,
    pub output_utxo: Option<OutPoint>,
    pub introduction_channel: Option<OutPoint>,
    pub output_channel: Option<Vec<OutPoint>>,
    pub introduction_node: PublicKey,
    pub amount_sats: u64,
    pub sats_sent: u64,
    pub change_amt: Option<u64>,
    pub fees_paid: u64,
    pub pending_payment: Option<String>,
}

Fields

id: [u8; 16]

input_utxo: OutPoint

status: RedshiftStatus

sending_node: PublicKey

recipient: RedshiftRecipient

receiving_node: Option<PublicKey>

The node that will receive the lightning payment. This will be one of Mutiny’s internal nodes.

output_utxo: Option<OutPoint>

introduction_channel: Option<OutPoint>

output_channel: Option<Vec<OutPoint>>

output_channel will be None if being kept in lightning, this is only relevant when the channels will be closed into an on chain address

introduction_node: PublicKey

amount_sats: u64

sats_sent: u64

change_amt: Option<u64>

fees_paid: u64

pending_payment: Option<String>

Payment hash of pending payment.

Implementations

impl Redshift

pub fn channel_opened(&mut self, chan_id: OutPoint)

pub fn payment_successful(&mut self, amount: u64, fees_paid: u64)

pub fn fail(&mut self, error: String)

Trait Implementations

impl Clone for Redshift

fn clone(&self) -> Redshift

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Redshift

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Redshift

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

Deserialize this value from the given Serde deserializer.

impl PartialEq for Redshift

fn eq(&self, other: &Redshift) -> 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 Serialize for Redshift

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Redshift