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>>, ) -> Self

Create a new VLS client with the given transport

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_inbound_payment_key_material(&self) -> KeyMaterial

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

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, hrp_bytes: &[u8], invoice_data: &[u5], 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_bolt12_invoice_request( &self, _invoice_request: &UnsignedInvoiceRequest, ) -> Result<Signature, ()>

Signs the TaggedHash of a BOLT 12 invoice request.

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

Sign a gossip message.

impl OutputSpender for KeysManagerClient

fn spend_spendable_outputs<C: Signing>( &self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec<TxOut>, change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, locktime: Option<LockTime>, _secp_ctx: &Secp256k1<C>, ) -> 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 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::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_value_satoshis: u64, channel_keys_id: [u8; 32], ) -> Self::EcdsaSigner

Derives the private key material backing a Signer.

fn read_chan_signer( &self, reader: &[u8], ) -> Result<Self::EcdsaSigner, 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, _: [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.