Struct breez_sdk_core::lightning::sign::PhantomKeysManager

pub struct PhantomKeysManager { /* private fields */ }

Similar to KeysManager, but allows the node using this struct to receive phantom node payments.

A phantom node payment is a payment made to a phantom invoice, which is an invoice that can be paid to one of multiple nodes. This works because we encode the invoice route hints such that LDK will recognize an incoming payment as destined for a phantom node, and collect the payment itself without ever needing to forward to this fake node.

Phantom node payments are useful for load balancing between multiple LDK nodes. They also provide some fault tolerance, because payers will automatically retry paying other provided nodes in the case that one node goes down.

Note that multi-path payments are not supported in phantom invoices for security reasons. Switching between this struct and KeysManager will invalidate any previously issued invoices and attempts to pay previous invoices will fail.

Implementations

impl PhantomKeysManager

pub fn new( seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, cross_node_seed: &[u8; 32], ) -> PhantomKeysManager

Constructs a PhantomKeysManager given a 32-byte seed and an additional cross_node_seed that is shared across all nodes that intend to participate in phantom node payments together.

See KeysManager::new for more information on seed, starting_time_secs, and starting_time_nanos.

cross_node_seed must be the same across all phantom payment-receiving nodes and also the same across restarts, or else inbound payments may fail.

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

where C: Signing,

See KeysManager::spend_spendable_outputs for documentation on this method.

pub fn derive_channel_keys( &self, channel_value_satoshis: u64, params: &[u8; 32], ) -> InMemorySigner

See KeysManager::derive_channel_keys for documentation on this method.

pub fn get_node_secret_key(&self) -> SecretKey

Gets the “node_id” secret key used to sign gossip announcements, decode onion data, etc.

pub fn get_phantom_node_secret_key(&self) -> SecretKey

Gets the “node_id” secret key of the phantom node used to sign invoices, decode the last-hop onion data, etc.

Trait Implementations

impl EntropySource for PhantomKeysManager

fn get_secure_random_bytes(&self) -> [u8; 32]

Gets a unique, cryptographically-secure, random 32-byte value. This method must return a different value each time it is called.

impl NodeSigner for PhantomKeysManager

fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()>

Get node id based on the provided Recipient.

fn ecdh( &self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>, ) -> Result<SharedSecret, ()>

Gets the ECDH shared secret of our node secret and other_key, multiplying by tweak if one is provided. Note that this tweak can be applied to other_key instead of our node secret, though this is less efficient.

fn get_inbound_payment_key_material(&self) -> KeyMaterial

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

fn sign_invoice( &self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient, ) -> Result<RecoverableSignature, ()>

Sign an invoice.

fn sign_bolt12_invoice_request( &self, invoice_request: &UnsignedInvoiceRequest, ) -> Result<Signature, ()>

Signs the TaggedHash of a BOLT 12 invoice request.

fn sign_bolt12_invoice( &self, invoice: &UnsignedBolt12Invoice, ) -> Result<Signature, ()>

Signs the TaggedHash of a BOLT 12 invoice.

fn sign_gossip_message( &self, msg: UnsignedGossipMessage<'_>, ) -> Result<Signature, ()>

Sign a gossip message.

impl SignerProvider for PhantomKeysManager

type Signer = InMemorySigner

A type which implements WriteableEcdsaChannelSigner which will be returned by Self::derive_channel_signer.

fn generate_channel_keys_id( &self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128, ) -> [u8; 32]

Generates a unique channel_keys_id that can be used to obtain a Self::Signer through SignerProvider::derive_channel_signer. The user_channel_id is provided to allow implementations of SignerProvider to maintain a mapping between itself and the generated channel_keys_id.

fn derive_channel_signer( &self, channel_value_satoshis: u64, channel_keys_id: [u8; 32], ) -> <PhantomKeysManager as SignerProvider>::Signer

Derives the private key material backing a Signer.

fn read_chan_signer( &self, reader: &[u8], ) -> Result<<PhantomKeysManager as SignerProvider>::Signer, DecodeError>

Reads a Signer for this SignerProvider from the given input stream. This is only called during deserialization of other objects which contain WriteableEcdsaChannelSigner-implementing objects (i.e., ChannelMonitors and ChannelManagers). The bytes are exactly those which <Self::Signer as Writeable>::write() writes, and contain no versioning scheme. You may wish to include your own version prefix and ensure you’ve read all of the provided bytes to ensure no corruption occurred.

fn get_destination_script(&self) -> Result<Script, ()>

Get a script pubkey which we send funds to when claiming on-chain contestable outputs.

fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()>

Get a script pubkey which we will send funds to when closing a channel.