Struct CommitmentOutputs 

pub struct CommitmentOutputs {
    pub receiver_outputs: DeterministicOutputsForOneContext,
    pub sender_outputs: DeterministicOutputsForOneContext,
}

Commitment outputs for a specific balance distribution Contains the deterministic outputs for both sender (Alice) and receiver (Charlie) at a specific balance point in the channel

Fields

receiver_outputs: DeterministicOutputsForOneContext

Receiver’s (Charlie’s) deterministic outputs

sender_outputs: DeterministicOutputsForOneContext

Sender’s (Alice’s) deterministic outputs

Implementations

impl CommitmentOutputs

pub fn new( receiver_outputs: DeterministicOutputsForOneContext, sender_outputs: DeterministicOutputsForOneContext, ) -> Self

Create new commitment outputs

pub fn for_balance( receiver_balance: u64, params: &ChannelParameters, ) -> Result<Self>

Create commitment outputs for a given receiver balance

Given the receiver’s (Charlie’s) desired final balance, this creates:

• One DeterministicOutputsForOneContext for the receiver (Charlie)
• One DeterministicOutputsForOneContext for the sender (Alice) with the remainder

The process:

1. Use inverse function to find nominal value for receiver’s deterministic outputs
2. Calculate sender’s nominal value as: amount_after_stage1 - receiver_nominal
3. Create both sets of outputs wrapped in CommitmentOutputs

Parameters:

• receiver_balance: The desired final balance for the receiver (after stage 2 fees)
• params: Channel parameters

Returns CommitmentOutputs containing both receiver and sender outputs

pub fn create_swap_request( &self, funding_proofs: Vec<Proof>, override_keyset_id: Option<Id>, ) -> Result<SwapRequest, Error>

Create an unsigned swap request from this commitment

Takes the funding proofs and creates a SwapRequest with:

• Inputs: all funding proofs
• Outputs: all outputs sorted by amount (stable) for privacy

The swap request is unsigned and needs to be signed by the sender (Alice) before sending

pub fn unblind_all( &self, blind_signatures: Vec<BlindSignature>, active_keys: &Keys, ) -> Result<Vec<ProofWithMetadata>, Error>

Unblind all outputs from a swap response

Takes the blind signatures from the swap response and returns a vector of ProofWithMetadata containing each proof along with its amount, index, and ownership flag.

The caller can filter by is_receiver to separate receiver/sender proofs.

pub async fn restore_all_blind_signatures<M>( &self, mint_connection: &M, ) -> Result<Vec<BlindSignature>, Error>

where M: MintConnection + ?Sized,

Restore blind signatures from the mint using NUT-09

This allows recovering the blind signatures for a commitment transaction without needing to have received them from the original swap. Since outputs are deterministic, we can recreate the blinded messages and ask the mint to restore the corresponding blind signatures.

Returns the blind signatures in the same order as create_swap_request: sorted by amount (stable) for privacy

Trait Implementations

impl Clone for CommitmentOutputs

fn clone(&self) -> CommitmentOutputs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommitmentOutputs

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

Formats the value using the given formatter.