Struct lightning_signer::util::loopback::LoopbackChannelSigner

pub struct LoopbackChannelSigner {
    pub node_id: PublicKey,
    pub channel_id: ChannelId,
    pub signer: Arc<MultiSigner>,
    pub pubkeys: ChannelPublicKeys,
    pub is_outbound: bool,
    pub channel_value_sat: u64,
}

Fields

node_id: PublicKey

channel_id: ChannelId

signer: Arc<MultiSigner>

pubkeys: ChannelPublicKeys

is_outbound: bool

channel_value_sat: u64

Implementations

impl LoopbackChannelSigner

pub fn make_counterparty_tx_keys(
    &self,
    per_commitment_point: &PublicKey,
    secp_ctx: &Secp256k1<All>
) -> Result<TxCreationKeys, ()>

Trait Implementations

impl BaseSign for LoopbackChannelSigner

fn get_per_commitment_point(
    &self,
    idx: u64,
    _secp_ctx: &Secp256k1<All>
) -> PublicKey

Gets the per-commitment point for a specific commitment number

fn release_commitment_secret(&self, commitment_number: u64) -> [u8; 32]

Gets the commitment secret for a specific commitment number as part of the revocation process

fn validate_holder_commitment(
    &self,
    holder_tx: &HolderCommitmentTransaction
) -> Result<(), ()>

Validate the counterparty’s signatures on the holder commitment transaction and HTLCs.

fn pubkeys(&self) -> &ChannelPublicKeys

Gets the holder’s channel public keys and basepoints

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

Gets an arbitrary identifier describing the set of keys which are provided back to you in some SpendableOutputDescriptor types. This should be sufficient to identify this Sign object uniquely and lookup or re-derive its keys.

fn sign_counterparty_commitment(
    &self,
    commitment_tx: &CommitmentTransaction,
    _secp_ctx: &Secp256k1<All>
) -> Result<(Signature, Vec<Signature>), ()>

Create a signature for a counterparty’s commitment transaction and associated HTLC transactions.

fn validate_counterparty_revocation(
    &self,
    idx: u64,
    secret: &SecretKey
) -> Result<(), ()>

Validate the counterparty’s revocation.

fn sign_holder_commitment_and_htlcs(
    &self,
    hct: &HolderCommitmentTransaction,
    _secp_ctx: &Secp256k1<All>
) -> Result<(Signature, Vec<Signature>), ()>

Create a signatures for a holder’s commitment transaction and its claiming HTLC transactions. This will only ever be called with a non-revoked commitment_tx. This will be called with the latest commitment_tx when we initiate a force-close. This will be called with the previous latest, just to get claiming HTLC signatures, if we are reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to the latest. This may be called multiple times for the same transaction.

fn unsafe_sign_holder_commitment_and_htlcs(
    &self,
    hct: &HolderCommitmentTransaction,
    secp_ctx: &Secp256k1<All>
) -> Result<(Signature, Vec<Signature>), ()>

Same as sign_holder_commitment, but exists only for tests to get access to holder commitment transactions which will be broadcasted later, after the channel has moved on to a newer state. Thus, needs its own method as sign_holder_commitment may enforce that we only ever get called once.

fn sign_justice_revoked_output(
    &self,
    justice_tx: &Transaction,
    input: usize,
    amount: u64,
    per_commitment_key: &SecretKey,
    secp_ctx: &Secp256k1<All>
) -> Result<Signature, ()>

Create a signature for the given input in a transaction spending an HTLC transaction output or a commitment transaction to_local output when our counterparty broadcasts an old state.

fn sign_justice_revoked_htlc(
    &self,
    justice_tx: &Transaction,
    input: usize,
    amount: u64,
    per_commitment_key: &SecretKey,
    htlc: &HTLCOutputInCommitment,
    secp_ctx: &Secp256k1<All>
) -> Result<Signature, ()>

Create a signature for the given input in a transaction spending a commitment transaction HTLC output when our counterparty broadcasts an old state.

fn sign_counterparty_htlc_transaction(
    &self,
    htlc_tx: &Transaction,
    input: usize,
    amount: u64,
    per_commitment_point: &PublicKey,
    htlc: &HTLCOutputInCommitment,
    secp_ctx: &Secp256k1<All>
) -> Result<Signature, ()>

Create a signature for a claiming transaction for a HTLC output on a counterparty’s commitment transaction, either offered or received.

fn sign_closing_transaction(
    &self,
    closing_tx: &ClosingTransaction,
    _secp_ctx: &Secp256k1<All>
) -> Result<Signature, ()>

Create a signature for a (proposed) closing transaction.

fn sign_channel_announcement(
    &self,
    msg: &UnsignedChannelAnnouncement,
    _secp_ctx: &Secp256k1<All>
) -> Result<Signature, ()>

Signs a channel announcement message with our funding key, proving it comes from one of the channel participants.

fn ready_channel(&mut self, parameters: &ChannelTransactionParameters)

Set the counterparty static channel data, including basepoints, counterparty_selected/holder_selected_contest_delay and funding outpoint. This is done as soon as the funding outpoint is known. Since these are static channel data, they MUST NOT be allowed to change to different values once set.

impl Clone for LoopbackChannelSigner

fn clone(&self) -> LoopbackChannelSigner

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Persist<LoopbackChannelSigner> for TestPersister

fn persist_new_channel(
    &self,
    _funding_txo: OutPoint,
    _data: &ChannelMonitor<LoopbackChannelSigner>,
    _id: MonitorUpdateId
) -> Result<(), ChannelMonitorUpdateErr>

Persist a new channel’s data in response to a chain::Watch::watch_channel call. This is called by ChannelManager for new channels, or may be called directly, e.g. on startup.

fn update_persisted_channel(
    &self,
    _funding_txo: OutPoint,
    _update: &Option<ChannelMonitorUpdate>,
    _data: &ChannelMonitor<LoopbackChannelSigner>,
    _id: MonitorUpdateId
) -> Result<(), ChannelMonitorUpdateErr>

Update one channel’s data. The provided ChannelMonitor has already applied the given update.

impl<'a> Watch<LoopbackChannelSigner> for TestChainMonitor<'a>

fn watch_channel(
    &self,
    funding_txo: OutPoint,
    monitor: ChannelMonitor<LoopbackChannelSigner>
) -> Result<(), ChannelMonitorUpdateErr>

Watches a channel identified by funding_txo using monitor.

fn update_channel(
    &self,
    funding_txo: OutPoint,
    update: ChannelMonitorUpdate
) -> Result<(), ChannelMonitorUpdateErr>

Updates a channel identified by funding_txo by applying update to its monitor.

fn release_pending_monitor_events(&self) -> Vec<MonitorEvent>

Returns any monitor events since the last call. Subsequent calls must only return new events.

impl Writeable for LoopbackChannelSigner

fn write<W: Writer>(&self, writer: &mut W) -> Result<(), IOError>

Writes self out to the given Writer

fn encode(&self) -> Vec<u8, Global>

Writes self out to a Vec

fn encode_with_len(&self) -> Vec<u8, Global>

Writes self out to a Vec

fn serialized_length(&self) -> usize

Gets the length of this object after it has been serialized. This can be overridden to optimize cases where we prepend an object with its length.

impl Sign for LoopbackChannelSigner