Struct ldk_node::Node

pub struct Node { /* private fields */ }

The main interface object of LDK Node, wrapping the necessary LDK and BDK functionalities.

Needs to be initialized and instantiated through Builder::build.

Implementations

impl Node

pub fn start(&self) -> Result<(), Error>

Starts the necessary background tasks, such as handling events coming from user input, LDK/BDK, and the peer-to-peer network.

After this returns, the Node instance can be controlled via the provided API methods in a thread-safe manner.

pub fn stop(&self) -> Result<(), Error>

Disconnects all peers, stops all running background tasks, and shuts down Node.

After this returns most API methods will return Error::NotRunning.

pub fn next_event(&self) -> Event

Blocks until the next event is available.

Note: this will always return the same event until handling is confirmed via Node::event_handled.

pub fn event_handled(&self)

Confirm the last retrieved event handled.

Note: This MUST be called after each event has been handled.

pub fn node_id(&self) -> PublicKey

Returns our own node id

pub fn listening_address(&self) -> Option<&SocketAddr>

Returns our own listening address.

pub fn new_funding_address(&self) -> Result<Address, Error>

Retrieve a new on-chain/funding address.

pub fn onchain_balance(&self) -> Result<Balance, Error>

Retrieve the current on-chain balance.

pub fn send_to_onchain_address( &self, address: &Address, amount_sats: u64 ) -> Result<Txid, Error>

Send an on-chain payment to the given address.

pub fn send_all_to_onchain_address( &self, address: &Address ) -> Result<Txid, Error>

Send an on-chain payment to the given address, draining all the available funds.

pub fn list_channels(&self) -> Vec<ChannelDetails>

Retrieve a list of known channels.

pub fn connect( &self, node_id: PublicKey, address: SocketAddr, permanently: bool ) -> Result<(), Error>

Connect to a node on the peer-to-peer network.

If permanently is set to true, we’ll remember the peer and reconnect to it on restart.

pub fn disconnect(&self, counterparty_node_id: &PublicKey) -> Result<(), Error>

Disconnects the peer with the given node id.

Will also remove the peer from the peer store, i.e., after this has been called we won’t try to reconnect on restart.

pub fn connect_open_channel( &self, node_id: PublicKey, address: SocketAddr, channel_amount_sats: u64, push_to_counterparty_msat: Option<u64>, announce_channel: bool ) -> Result<(), Error>

Connect to a node and open a new channel. Disconnects and re-connects are handled automatically

Disconnects and reconnects are handled automatically.

If push_to_counterparty_msat is set, the given value will be pushed (read: sent) to the channel counterparty on channel open. This can be useful to start out with the balance not entirely shifted to one side, therefore allowing to receive payments from the getgo.

Returns a temporary channel id.

pub fn sync_wallets(&self) -> Result<(), Error>

Sync the LDK and BDK wallets with the current chain state.

Note that the wallets will be also synced regularly in the background.

pub fn close_channel( &self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey ) -> Result<(), Error>

Close a previously opened channel.

pub fn send_payment(&self, invoice: &Invoice) -> Result<PaymentHash, Error>

Send a payement given an invoice.

pub fn send_payment_using_amount( &self, invoice: &Invoice, amount_msat: u64 ) -> Result<PaymentHash, Error>

Send a payment given an invoice and an amount in millisatoshi.

This will fail if the amount given is less than the value required by the given invoice.

This can be used to pay a so-called “zero-amount” invoice, i.e., an invoice that leaves the amount paid to be determined by the user.

pub fn send_spontaneous_payment( &self, amount_msat: u64, node_id: &PublicKey ) -> Result<PaymentHash, Error>

Send a spontaneous, aka. “keysend”, payment

pub fn receive_payment( &self, amount_msat: u64, description: &str, expiry_secs: u32 ) -> Result<Invoice, Error>

Returns a payable invoice that can be used to request and receive a payment of the amount given.

pub fn receive_variable_amount_payment( &self, description: &str, expiry_secs: u32 ) -> Result<Invoice, Error>

Returns a payable invoice that can be used to request and receive a payment for which the amount is to be determined by the user, also known as a “zero-amount” invoice.

pub fn payment(&self, payment_hash: &PaymentHash) -> Option<PaymentDetails>

Retrieve the details of a specific payment with the given hash.

Returns Some if the payment was known and None otherwise.

pub fn remove_payment(&self, payment_hash: &PaymentHash) -> Result<bool, Error>

Remove the payment with the given hash from the store.

Returns true if the payment was present and false otherwise.

pub fn list_payments_with_filter<F: FnMut(&&PaymentDetails) -> bool>( &self, f: F ) -> Vec<PaymentDetails>

Retrieves all payments that match the given predicate.

For example, you could retrieve all stored outbound payments as follows:

node.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound);