Struct lnrpc::Channel

pub struct Channel {
    pub active: bool,
    pub remote_pubkey: String,
    pub channel_point: String,
    pub chan_id: u64,
    pub capacity: i64,
    pub local_balance: i64,
    pub remote_balance: i64,
    pub commit_fee: i64,
    pub commit_weight: i64,
    pub fee_per_kw: i64,
    pub unsettled_balance: i64,
    pub total_satoshis_sent: i64,
    pub total_satoshis_received: i64,
    pub num_updates: u64,
    pub pending_htlcs: Vec<Htlc>,
    pub csv_delay: u32,
    pub private: bool,
    pub initiator: bool,
    pub chan_status_flags: String,
    pub local_chan_reserve_sat: i64,
    pub remote_chan_reserve_sat: i64,
    pub static_remote_key: bool,
    pub commitment_type: i32,
    pub lifetime: i64,
    pub uptime: i64,
    pub close_address: String,
    pub push_amount_sat: u64,
    pub thaw_height: u32,
}

Fields

active: bool

remote_pubkey: String

channel_point: String

The outpoint (txid:index) of the funding transaction. With this value, Bob will be able to generate a signature for Alice's version of the commitment transaction.

chan_id: u64

The unique channel ID for the channel. The first 3 bytes are the block height, the next 3 the index within the block, and the last 2 bytes are the output index for the channel.

capacity: i64

local_balance: i64

remote_balance: i64

commit_fee: i64

The amount calculated to be paid in fees for the current set of commitment transactions. The fee amount is persisted with the channel in order to allow the fee amount to be removed and recalculated with each channel state update, including updates that happen after a system restart.

commit_weight: i64

fee_per_kw: i64

The required number of satoshis per kilo-weight that the requester will pay at all times, for both the funding transaction and commitment transaction. This value can later be updated once the channel is open.

unsettled_balance: i64

total_satoshis_sent: i64

The total number of satoshis we've sent within this channel.

total_satoshis_received: i64

The total number of satoshis we've received within this channel.

num_updates: u64

The total number of updates conducted within this channel.

pending_htlcs: Vec<Htlc>

The list of active, uncleared HTLCs currently pending within the channel.

csv_delay: u32

The CSV delay expressed in relative blocks. If the channel is force closed, we will need to wait for this many blocks before we can regain our funds.

private: bool

initiator: bool

chan_status_flags: String

local_chan_reserve_sat: i64

remote_chan_reserve_sat: i64

The minimum satoshis the other node is required to reserve in its balance.

static_remote_key: bool

commitment_type: i32

lifetime: i64

The number of seconds that the channel has been monitored by the channel scoring system. Scores are currently not persisted, so this value may be less than the lifetime of the channel [EXPERIMENTAL].

uptime: i64

The number of seconds that the remote peer has been observed as being online by the channel scoring system over the lifetime of the channel [EXPERIMENTAL].

close_address: String

Close address is the address that we will enforce payout to on cooperative close if the channel was opened utilizing option upfront shutdown. This value can be set on channel open by setting close_address in an open channel request. If this value is not set, you can still choose a payout address by cooperatively closing with the delivery_address field set.

push_amount_sat: u64

The amount that the initiator of the channel optionally pushed to the remote party on channel open. This amount will be zero if the channel initiator did not push any funds to the remote peer. If the initiator field is true, we pushed this amount to our peer, if it is false, the remote peer pushed this amount to us.

thaw_height: u32

This uint32 indicates if this channel is to be considered 'frozen'. A frozen channel doest not allow a cooperative channel close by the initiator. The thaw_height is the height that this restriction stops applying to the channel. This field is optional, not setting it or using a value of zero will mean the channel has no additional restrictions.

Implementations

impl Channel

pub fn commitment_type(&self) -> CommitmentType

Returns the enum value of commitment_type, or the default if the field is set to an invalid enum value.

pub fn set_commitment_type(&mut self, value: CommitmentType)

Sets commitment_type to the provided enum value.

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Channel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Channel

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

Formats the value using the given formatter.

impl Default for Channel

fn default() -> Channel

Returns the "default value" for a type.

impl Message for Channel

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Channel> for Channel

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Channel) -> bool

This method tests for !=.

impl StructuralPartialEq for Channel