Enum lightning::util::events::Event

pub enum Event {
    FundingGenerationReady {
        temporary_channel_id: [u8; 32],
        channel_value_satoshis: u64,
        output_script: Script,
        user_channel_id: u64,
    },
    FundingBroadcastSafe {
        funding_txo: OutPoint,
        user_channel_id: u64,
    },
    PaymentReceived {
        payment_hash: PaymentHash,
        payment_secret: Option<PaymentSecret>,
        amt: u64,
    },
    PaymentSent {
        payment_preimage: PaymentPreimage,
    },
    PaymentFailed {
        payment_hash: PaymentHash,
        rejected_by_dest: bool,
    },
    PendingHTLCsForwardable {
        time_forwardable: Duration,
    },
    SpendableOutputs {
        outputs: Vec<SpendableOutputDescriptor>,
    },
}

An Event which you should probably take some action in response to.

Note that while Writeable and Readable are implemented for Event, you probably shouldn't use them directly as they don't round-trip exactly (for example FundingGenerationReady is never written as it makes no sense to respond to it after reconnecting to peers).

Variants

FundingGenerationReady

Used to indicate that the client should generate a funding transaction with the given parameters and then call ChannelManager::funding_transaction_generated. Generated in ChannelManager message handling. Note that all inputs in the funding transaction must spend SegWit outputs or your counterparty can steal your funds!

Fields of FundingGenerationReady

temporary_channel_id: [u8; 32]

The random channel_id we picked which you'll need to pass into ChannelManager::funding_transaction_generated.

channel_value_satoshis: u64

The value, in satoshis, that the output should have.

output_script: Script

The script which should be used in the transaction output.

user_channel_id: u64

The value passed in to ChannelManager::create_channel

FundingBroadcastSafe

Used to indicate that the client may now broadcast the funding transaction it created for a channel. Broadcasting such a transaction prior to this event may lead to our counterparty trivially stealing all funds in the funding transaction!

Fields of FundingBroadcastSafe

funding_txo: OutPoint

The output, which was passed to ChannelManager::funding_transaction_generated, which is now safe to broadcast.

user_channel_id: u64

The value passed in to ChannelManager::create_channel

PaymentReceived

Indicates we've received money! Just gotta dig out that payment preimage and feed it to ChannelManager::claim_funds to get it.... Note that if the preimage is not known or the amount paid is incorrect, you should call ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid network congestion. The amount paid should be considered 'incorrect' when it is less than or more than twice the amount expected. If you fail to call either ChannelManager::claim_funds or ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be automatically failed.

Fields of PaymentReceived

payment_hash: PaymentHash

The hash for which the preimage should be handed to the ChannelManager.

payment_secret: Option<PaymentSecret>

The "payment secret". This authenticates the sender to the recipient, preventing a number of deanonymization attacks during the routing process. As nodes upgrade, the invoices you provide should likely migrate to setting the payment_secret feature to required, at which point you should fail_backwards any HTLCs which have a None here. Until then, however, values of None should be ignored, and only incorrect Some values should result in an HTLC fail_backwards. Note that, in any case, this value must be passed as-is to any fail or claim calls as the HTLC index includes this value.

amt: u64

The value, in thousandths of a satoshi, that this payment is for. Note that you must compare this to the expected value before accepting the payment (as otherwise you are providing proof-of-payment for less than the value you expected!).

PaymentSent

Indicates an outbound payment we made succeeded (ie it made it all the way to its target and we got back the payment preimage for it). Note that duplicative PaymentSent Events may be generated - it is your responsibility to deduplicate them by payment_preimage (which MUST be unique)!

Fields of PaymentSent

payment_preimage: PaymentPreimage

The preimage to the hash given to ChannelManager::send_payment. Note that this serves as a payment receipt, if you wish to have such a thing, you must store it somehow!

PaymentFailed

Indicates an outbound payment we made failed. Probably some intermediary node dropped something. You may wish to retry with a different route. Note that duplicative PaymentFailed Events may be generated - it is your responsibility to deduplicate them by payment_hash (which MUST be unique)!

Fields of PaymentFailed

payment_hash: PaymentHash

The hash which was given to ChannelManager::send_payment.

rejected_by_dest: bool

Indicates the payment was rejected for some reason by the recipient. This implies that the payment has failed, not just the route in question. If this is not set, you may retry the payment via a different route.

PendingHTLCsForwardable

Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a time in the future.

Fields of PendingHTLCsForwardable

time_forwardable: Duration

The minimum amount of time that should be waited prior to calling process_pending_htlc_forwards. To increase the effort required to correlate payments, you should wait a random amount of time in roughly the range (now + time_forwardable, now + 5*time_forwardable).

SpendableOutputs

Used to indicate that an output was generated on-chain which you should know how to spend. Such an output will not ever be spent by rust-lightning, and are not at risk of your counterparty spending them due to some kind of timeout. Thus, you need to store them somewhere and spend them when you create on-chain transactions.

Fields of SpendableOutputs

outputs: Vec<SpendableOutputDescriptor>

The outputs which you should store as spendable by you.

Trait Implementations

impl Clone for Event

pub fn clone(&self) -> Event

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl MaybeReadable for Event

pub fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>

Reads a Self in from the given Read

impl Writeable for Event

pub fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>

Writes self out to the given Writer

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

Writes self out to a Vec

pub fn encode_with_len(&self) -> Vec<u8>

Writes self out to a Vec