Struct HolderCommitmentTransaction 

pub struct HolderCommitmentTransaction {
    pub counterparty_sig: Signature,
    pub counterparty_htlc_sigs: Vec<Signature>,
    /* private fields */
}

Information needed to build and sign a holder’s commitment transaction.

The transaction is only signed once we are ready to broadcast.

Fields

counterparty_sig: Signature

Our counterparty’s signature for the transaction

counterparty_htlc_sigs: Vec<Signature>

All non-dust counterparty HTLC signatures, in the order they appear in the transaction

Implementations

impl HolderCommitmentTransaction

pub fn new( commitment_tx: CommitmentTransaction, counterparty_sig: Signature, counterparty_htlc_sigs: Vec<Signature>, holder_funding_key: &PublicKey, counterparty_funding_key: &PublicKey, ) -> Self

Create a new holder transaction with the given counterparty signatures. The funding keys are used to figure out which signature should go first when building the transaction for broadcast.

Methods from Deref<Target = CommitmentTransaction>

pub fn commitment_number(&self) -> u64

The backwards-counting commitment number

pub fn per_commitment_point(&self) -> PublicKey

The per commitment point used by the broadcaster.

pub fn to_broadcaster_value_sat(&self) -> u64

The value to be sent to the broadcaster

pub fn to_countersignatory_value_sat(&self) -> u64

The value to be sent to the counterparty

pub fn negotiated_feerate_per_kw(&self) -> u32

The feerate paid per 1000-weight-unit we negotiated with our peer for this commitment transaction. Note that the actual feerate of the commitment transaction may be higher than the negotiated feerate.

pub fn nondust_htlcs(&self) -> &Vec<HTLCOutputInCommitment>

The non-dust HTLCs (direction, amt, height expiration, hash, transaction output index) which were included in this commitment transaction in output order. The transaction index is always populated.

This is not exported to bindings users as we cannot currently convert Vec references to/from C, though we should expose a less effecient version which creates a Vec of references in the future.

pub fn trust(&self) -> TrustedCommitmentTransaction<'_>

Trust our pre-built transaction and derived transaction creation public keys.

Applies a wrapper which allows access to these fields.

This should only be used if you fully trust the builder of this object. It should not be used by an external signer - instead use the verify function.

pub fn verify<T: Signing + Verification>( &self, channel_parameters: &DirectedChannelTransactionParameters<'_>, secp_ctx: &Secp256k1<T>, ) -> Result<TrustedCommitmentTransaction<'_>, ()>

Verify our pre-built transaction and derived transaction creation public keys.

Applies a wrapper which allows access to these fields.

An external validating signer must call this method before signing or using the built transaction.

Trait Implementations

impl Clone for HolderCommitmentTransaction

fn clone(&self) -> HolderCommitmentTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HolderCommitmentTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for HolderCommitmentTransaction

type Target = CommitmentTransaction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl PartialEq for HolderCommitmentTransaction

fn eq(&self, o: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Readable for HolderCommitmentTransaction

fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError>

Reads a Self in from the given Read.

impl Writeable for HolderCommitmentTransaction

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

Writes self out to the given Writer.

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.

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

Writes self out to a Vec<u8>.

impl Eq for HolderCommitmentTransaction