Struct KeysManagerClient 

pub struct KeysManagerClient { /* private fields */ }

Implementations

impl KeysManagerClient

pub fn new( transport: Arc<dyn Transport>, network: String, key_derivation_style: Option<KeyDerivationStyle>, dev_allowlist: Option<Array<WireString>>, receive_auth_key: ReceiveAuthKey, ) -> Self

Create a new VLS client with the given transport.

receive_auth_key is the LDK 0.2 blinded-path MAC key. Its only requirement is to be consistent across invocations, so the caller is responsible for generating it (e.g. on first run) and persisting it in its own state — see NodeSigner::get_receive_auth_key in LDK. The signer does not provide it, since any caller with persistence can.

peer_storage_key and the inbound-payment ExpandedKey seed are in contrast obtained from the signer’s HsmdInit2Reply: LDK requires them to be stable across restarts (state-loss recovery, and receivable invoices respectively) and the signer is the only place that holds the seed they derive from.

pub fn call<T: SerBolt, R: DeBolt>(&self, message: T) -> Result<R, Error>

pub fn sign_onchain_tx( &self, tx: &Transaction, descriptors: &[&SpendableOutputDescriptor], ) -> Vec<Vec<Vec<u8>>>

Trait Implementations

impl EntropySource for KeysManagerClient

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 KeysManagerClient

fn get_expanded_key(&self) -> ExpandedKey

Get the ExpandedKey which provides cryptographic material for various Lightning Network operations.

fn get_peer_storage_key(&self) -> PeerStorageKey

Defines a method to derive a 32-byte encryption key for peer storage.

fn get_receive_auth_key(&self) -> ReceiveAuthKey

Returns the ReceiveAuthKey used to authenticate incoming BlindedMessagePath contexts.

fn sign_message(&self, msg: &[u8]) -> Result<String, ()>

Sign an arbitrary message with the node’s secret key.

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 sign_invoice( &self, invoice: &RawBolt11Invoice, recipient: Recipient, ) -> Result<RecoverableSignature, ()>

Sign an invoice.

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 OutputSpender for KeysManagerClient

fn spend_spendable_outputs( &self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec<TxOut>, change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, locktime: Option<LockTime>, _secp_ctx: &Secp256k1<All>, ) -> Result<Transaction, ()>

Creates a Transaction which spends the given descriptors to the given outputs, plus an output to the given change destination (if sufficient change value remains). The transaction will have a feerate, at least, of the given value.

impl SignerProvider for KeysManagerClient

type EcdsaSigner = SignerClient

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

fn generate_channel_keys_id( &self, _inbound: bool, _user_channel_id: u128, ) -> [u8; 32]

Generates a unique channel_keys_id that can be used to obtain a Self::EcdsaSigner 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_keys_id: [u8; 32]) -> Self::EcdsaSigner

Derives the private key material backing a Signer.

fn get_destination_script(&self, _: [u8; 32]) -> Result<ScriptBuf, ()>

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.