Struct RingCtBuilder 

pub struct RingCtBuilder { /* private fields */ }

Builder for creating Ring CT transactions

Implementations

impl RingCtBuilder

pub fn new() -> Self

Create a new Ring CT transaction builder

pub fn add_input(self, amount: u64, blinding: Scalar) -> Self

Add an input to the transaction

pub fn add_output(self, amount: u64, blinding: Scalar) -> Self

Add an output to the transaction

pub fn fee(self, fee: u64) -> Self

Set transaction fee (in smallest units)

pub fn add_decoys(self, decoys: Vec<PublicKey>) -> Self

Add decoy public keys for ring signature (for anonymity)

Decoy public keys are used to create a ring of possible signers, making it impossible to determine which key actually signed the transaction.

In a real Ring CT system, these should be real public keys from the blockchain to provide actual anonymity. The more decoys, the greater the anonymity set.

Example

let decoys = vec![
    some_real_public_key_1,
    some_real_public_key_2,
    some_real_public_key_3,
];
builder.add_decoys(decoys);

pub fn add_decoy(self, decoy: PublicKey) -> Self

Add a single decoy public key for ring signature

pub fn calculate_last_output_blinding(&self) -> Option<Scalar>

Calculate the required blinding factor for a new output to balance the transaction

For Ring CT transactions to verify correctly, the blinding factors must balance: sum(input_blindings) = sum(output_blindings) + fee_blinding

Since fee uses zero blinding, this simplifies to: sum(input_blindings) = sum(output_blindings)

This method calculates what the next output’s blinding factor should be to achieve this balance given all current inputs and outputs.

Returns None if there are no inputs.

pub fn add_output_auto_balance(self, amount: u64) -> Self

Add an output with automatic blinding factor calculation

This method automatically calculates the blinding factor needed to balance the transaction. It should only be used for the LAST output in a transaction.

Panics

Panics if there are no inputs (cannot calculate balance without inputs)

pub fn rebalance_last_output(self) -> Self

Rebalance the last output’s blinding factor to ensure transaction balance

This is useful if you’ve added all inputs and outputs but want to ensure the transaction is properly balanced. It recalculates the last output’s commitment with a new blinding factor that ensures balance.

Returns the builder for chaining.

Panics

Panics if there are no inputs or no outputs

pub fn build(self, signer: &KeyPair) -> RingCtResult<RingCtTransaction>

Build and sign the transaction with the given keypair

The keypair is used to create the ring signature proving ownership of one of the inputs without revealing which one.

Trait Implementations

impl Default for RingCtBuilder

fn default() -> Self

Returns the “default value” for a type.