Struct lightning_signer::node::Node

pub struct Node { /* fields omitted */ }

A signer for one Lightning node.

use lightning_signer::node::{Node, NodeConfig};
use lightning_signer::channel::{ChannelSlot, ChannelBase};
use lightning_signer::persist::{DummyPersister, Persist};
use lightning_signer::util::test_utils::TEST_NODE_CONFIG;
use lightning_signer::util::test_logger::TestLogger;
use lightning_signer::node::SyncLogger;

use std::sync::Arc;

let persister: Arc<dyn Persist> = Arc::new(DummyPersister {});
let seed = [0; 32];
let config = TEST_NODE_CONFIG;
let node = Arc::new(Node::new(config, &seed, &persister, vec![]));
let (channel_id, opt_stub) = node.new_channel(None, None, &node).expect("new channel");
assert!(opt_stub.is_some());
let channel_slot_mutex = node.get_channel(&channel_id).expect("get channel");
let channel_slot = channel_slot_mutex.lock().expect("lock");
match &*channel_slot {
    ChannelSlot::Stub(stub) => {
        // Do things with the stub, such as readying it or getting the points
        let holder_basepoints = stub.get_channel_basepoints();
    }
    ChannelSlot::Ready(_) => panic!("expected a stub")
}

Implementations

impl Node

pub fn new(
    node_config: NodeConfig,
    seed: &[u8],
    persister: &Arc<dyn Persist>,
    allowlist: Vec<Script>
) -> Node

Create a node.

NOTE: you must persist the node yourself if it is new.

pub fn new_extended(
    node_config: NodeConfig,
    seed: &[u8],
    persister: &Arc<dyn Persist>,
    allowlist: Vec<Script>,
    tracker: ChainTracker<ChainMonitor>,
    validator_factory: Box<dyn ValidatorFactory>
) -> Node

Create a node

NOTE: you must persist the node yourself if it is new.

pub fn new_from_persistence(
    node_config: NodeConfig,
    seed: &[u8],
    persister: &Arc<dyn Persist>,
    allowlist: Vec<Script>,
    tracker: ChainTracker<ChainMonitor>
) -> Node

Restore a node.

pub fn set_validator_factory(
    &self,
    validator_factory: Box<dyn ValidatorFactory>
)

Set the node’s validator factory

pub fn get_id(&self) -> PublicKey

Get the node ID, which is the same as the node public key

pub fn get_inbound_payment_key_material(&self) -> KeyMaterial

Get secret key material as bytes for use in encrypting and decrypting inbound payment data.

This method must return the same value each time it is called.

pub fn get_channel(
    &self,
    channel_id: &ChannelId
) -> Result<Arc<Mutex<ChannelSlot>>, Status>

Get the Mutex protected channel slot

pub fn with_channel_base<F: Sized, T>(
    &self,
    channel_id: &ChannelId,
    f: F
) -> Result<T, Status> where
    F: Fn(&mut dyn ChannelBase) -> Result<T, Status>, 

Execute a function with an existing channel.

The channel may be a stub or a ready channel. An invalid_argument Status will be returned if the channel does not exist.

pub fn with_ready_channel<F: Sized, T>(
    &self,
    channel_id: &ChannelId,
    f: F
) -> Result<T, Status> where
    F: Fn(&mut Channel) -> Result<T, Status>, 

Execute a function with an existing ready channel.

An invalid_argument Status will be returned if the channel does not exist.

pub fn find_channel_with_funding_outpoint(
    &self,
    outpoint: &OutPoint
) -> Option<Arc<Mutex<ChannelSlot>>>

Get a channel given its funding outpoint, or None if no such channel exists.

pub fn new_channel(
    &self,
    opt_channel_id: Option<ChannelId>,
    opt_channel_nonce0: Option<Vec<u8>>,
    arc_self: &Arc<Node>
) -> Result<(ChannelId, Option<ChannelStub>), Status>

Create a new channel, which starts out as a stub.

The initial channel ID may be specified in opt_channel_id. If the channel with this ID already exists, the existing stub is returned.

If unspecified, the channel nonce will default to the channel ID.

This function will return an invalid_argument Status if there is an existing channel with this ID and it’s not a compatible stub channel.

Returns the channel ID and the stub.

pub fn restore_node(
    node_id: &PublicKey,
    node_entry: NodeEntry,
    persister: Arc<dyn Persist>
) -> Arc<Node>

Restore a node from a persisted NodeEntry.

You can get the NodeEntry from Persist::get_nodes.

The channels are also restored from the persister.

pub fn restore_nodes(persister: Arc<dyn Persist>) -> Map<PublicKey, Arc<Node>>

Restore all nodes from persister.

The channels of each node are also restored.

pub fn ready_channel(
    &self,
    channel_id0: ChannelId,
    opt_channel_id: Option<ChannelId>,
    setup: ChannelSetup,
    holder_shutdown_key_path: &Vec<u32>
) -> Result<Channel, Status>

Ready a new channel, making it available for use.

This populates fields that are known later in the channel creation flow, such as fields that are supplied by the counterparty and funding outpoint.

• channel_id0 - the original channel ID supplied to Node::new_channel
• opt_channel_id - the permanent channel ID

The channel is promoted from a ChannelStub to a Channel. After this call, the channel may be referred to by either ID.

pub fn sign_onchain_tx(
    &self,
    tx: &Transaction,
    ipaths: &Vec<Vec<u32>>,
    values_sat: &Vec<u64>,
    spendtypes: &Vec<SpendType>,
    uniclosekeys: &Vec<Option<SecretKey>>,
    opaths: &Vec<Vec<u32>>
) -> Result<Vec<(Vec<u8>, Vec<u8>)>, Status>

Sign an onchain transaction (funding tx or simple sweeps).

The transaction may fund multiple channels at once. Returns a witness stack for each input. Inputs that are marked as SpendType::Invalid are not signed and get an empty witness stack.

• ipaths - derivation path for the wallet key per input
• values_sat - the amount in satoshi per input
• spendtypes - spend type per input, or Invalid if this input is to be signed by someone else.
• uniclosekeys - an optional unilateral close key to use instead of the wallet key. Takes precedence over the ipaths entry. This is used when we are sweeping a unilateral close and funding a channel in a single tx.
• opaths - derivation path for change, one per output. Empty for non-change outputs.

pub fn get_node_secret(&self) -> SecretKey

Get the node secret key This function will be eliminated once the node key related items are implemented. This includes onion decoding and p2p handshake.

pub fn get_ldk_shutdown_scriptpubkey(&self) -> ShutdownScript

Get shutdown_pubkey to use as PublicKey at channel closure

pub fn get_account_extended_key(&self) -> &ExtendedPrivKey

Get the layer-1 xprv

pub fn get_account_extended_pubkey(&self) -> ExtendedPubKey

Get the layer-1 xpub

pub fn sign_node_announcement(&self, na: &Vec<u8>) -> Result<Vec<u8>, Status>

Sign a node announcement using the node key

pub fn sign_channel_update(&self, cu: &Vec<u8>) -> Result<Vec<u8>, Status>

Sign a channel update using the node key

pub fn sign_invoice_in_parts(
    &self,
    data_part: &Vec<u8>,
    human_readable_part: &String
) -> Result<Vec<u8>, Status>

Sign an invoice

pub fn sign_invoice(&self, invoice_preimage: &Vec<u8>) -> RecoverableSignature

Sign an invoice

pub fn sign_message(&self, message: &Vec<u8>) -> Result<Vec<u8>, Status>

Sign a Lightning message

pub fn channels(
    &self
) -> MutexGuard<'_, Map<ChannelId, Arc<Mutex<ChannelSlot>>>>

Get the channels this node knows about. Currently, channels are not pruned once closed, but this will change.

pub fn ecdh(&self, other_key: &PublicKey) -> Vec<u8>

Perform an ECDH operation between the node key and a public key This can be used for onion packet decoding

pub fn spend_spendable_outputs(
    &self,
    descriptors: &[&SpendableOutputDescriptor],
    outputs: Vec<TxOut>,
    change_destination_script: Script,
    feerate_sat_per_1000_weight: u32,
    secp_ctx: &Secp256k1<All>
) -> Result<Transaction, ()>

See MyKeysManager::spend_spendable_outputs.

For LDK compatibility.

pub fn allowlist(&self) -> Result<Vec<String>, Status>

Returns the node’s current allowlist.

pub fn add_allowlist(&self, addlist: &Vec<String>) -> Result<(), Status>

Adds addresses to the node’s current allowlist.

pub fn remove_allowlist(&self, rmlist: &Vec<String>) -> Result<(), Status>

Removes addresses from the node’s current allowlist.

pub fn get_tracker(&self) -> MutexGuard<'_, ChainTracker<ChainMonitor>>

Chain tracker with lock

Trait Implementations

impl Debug for Node

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

Formats the value using the given formatter.

impl Wallet for Node

fn allowlist_contains(&self, script_pubkey: &Script) -> bool

Returns true if script_pubkey is in the node’s allowlist.

fn can_spend(
    &self,
    child_path: &Vec<u32>,
    script_pubkey: &Script
) -> Result<bool, Status>

True if the wallet can spend the given output with a derived key

fn network(&self) -> Network

Returns the network