Trait EcdsaChannelSigner

pub trait EcdsaChannelSigner: ChannelSigner {
    // Required methods
    fn sign_counterparty_commitment(
        &self,
        commitment_tx: &CommitmentTransaction,
        preimages: Vec<PaymentPreimage>,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<(Signature, Vec<Signature>), ()>;
    fn validate_counterparty_revocation(
        &self,
        idx: u64,
        secret: &SecretKey,
    ) -> Result<(), ()>;
    fn sign_holder_commitment(
        &self,
        commitment_tx: &HolderCommitmentTransaction,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
    fn sign_justice_revoked_output(
        &self,
        justice_tx: &Transaction,
        input: usize,
        amount: u64,
        per_commitment_key: &SecretKey,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
    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, ()>;
    fn sign_holder_htlc_transaction(
        &self,
        htlc_tx: &Transaction,
        input: usize,
        htlc_descriptor: &HTLCDescriptor,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
    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, ()>;
    fn sign_closing_transaction(
        &self,
        closing_tx: &ClosingTransaction,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
    fn sign_holder_anchor_input(
        &self,
        anchor_tx: &Transaction,
        input: usize,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
    fn sign_channel_announcement_with_funding_key(
        &self,
        msg: &UnsignedChannelAnnouncement,
        secp_ctx: &Secp256k1<All>,
    ) -> Result<Signature, ()>;
}

A trait to sign Lightning channel transactions as described in BOLT 3.

Signing services could be implemented on a hardware wallet and should implement signing policies in order to be secure. Please refer to the VLS Policy Controls for an example of such policies.

Required Methods

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

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

Note that if signing fails or is rejected, the channel will be force-closed.

Policy checks should be implemented in this function, including checking the amount sent to us and checking the HTLCs.

The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided. A validating signer should ensure that an HTLC output is removed only when the matching preimage is provided, or when the value to holder is restored.

Note that all the relevant preimages will be provided, but there may also be additional irrelevant or duplicate preimages.

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

Validate the counterparty’s revocation.

This is required in order for the signer to make sure that the state has moved forward and it is safe to sign the next counterparty commitment.

fn sign_holder_commitment( &self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1<All>, ) -> Result<Signature, ()>

Creates a signature for a holder’s commitment transaction.

This will be called

• with a non-revoked commitment_tx.
• with the latest commitment_tx when we initiate a force-close.

This may be called multiple times for the same transaction.

An external signer implementation should check that the commitment has not been revoked.

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.

A justice transaction may claim multiple outputs at the same time if timelocks are similar, but only a signature for the input at index input should be signed for here. It may be called multiple times for same output(s) if a fee-bump is needed with regards to an upcoming timelock expiration.

Amount is value of the output spent by this input, committed to in the BIP 143 signature.

per_commitment_key is revocation secret which was provided by our counterparty when they revoked the state which they eventually broadcast. It’s not a holder secret key and does not allow the spending of any funds by itself (you need our holder revocation_secret to do so).

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.

A justice transaction may claim multiple outputs at the same time if timelocks are similar, but only a signature for the input at index input should be signed for here. It may be called multiple times for same output(s) if a fee-bump is needed with regards to an upcoming timelock expiration.

amount is the value of the output spent by this input, committed to in the BIP 143 signature.

per_commitment_key is revocation secret which was provided by our counterparty when they revoked the state which they eventually broadcast. It’s not a holder secret key and does not allow the spending of any funds by itself (you need our holder revocation_secret to do so).

htlc holds HTLC elements (hash, timelock), thus changing the format of the witness script (which is committed to in the BIP 143 signatures).

fn sign_holder_htlc_transaction( &self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1<All>, ) -> Result<Signature, ()>

Computes the signature for a commitment transaction’s HTLC output used as an input within htlc_tx, which spends the commitment transaction at index input. The signature returned must be be computed using EcdsaSighashType::All.

Note that this may be called for HTLCs in the penultimate commitment transaction if a ChannelMonitor replica broadcasts it before receiving the update for the latest commitment transaction.

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.

Such a transaction may claim multiples offered outputs at same time if we know the preimage for each when we create it, but only the input at index input should be signed for here. It may be called multiple times for same output(s) if a fee-bump is needed with regards to an upcoming timelock expiration.

witness_script is either an offered or received script as defined in BOLT3 for HTLC outputs.

amount is value of the output spent by this input, committed to in the BIP 143 signature.

per_commitment_point is the dynamic point corresponding to the channel state detected onchain. It has been generated by our counterparty and is used to derive channel state keys, which are then included in the witness script and committed to in the BIP 143 signature.

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

Create a signature for a (proposed) closing transaction.

Note that, due to rounding, there may be one “missing” satoshi, and either party may have chosen to forgo their output as dust.

fn sign_holder_anchor_input( &self, anchor_tx: &Transaction, input: usize, secp_ctx: &Secp256k1<All>, ) -> Result<Signature, ()>

Computes the signature for a commitment transaction’s anchor output used as an input within anchor_tx, which spends the commitment transaction, at index input.

fn sign_channel_announcement_with_funding_key( &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.

Channel announcements also require a signature from each node’s network key. Our node signature is computed through NodeSigner::sign_gossip_message.

Note that if this fails or is rejected, the channel will not be publicly announced and our counterparty may (though likely will not) close the channel on us for violating the protocol.

Implementors

impl EcdsaChannelSigner for InMemorySigner