Struct SignableTransaction 

pub struct SignableTransaction {
    rct_type: RctType,
    outgoing_view_key: Zeroizing<[u8; 32]>,
    inputs: Vec<OutputWithDecoys>,
    payments: Vec<InternalPayment>,
    data: Vec<Vec<u8>>,
    fee_rate: FeeRate,
}

A signable transaction.

Fields

rct_type: RctType

outgoing_view_key: Zeroizing<[u8; 32]>

inputs: Vec<OutputWithDecoys>

payments: Vec<InternalPayment>

data: Vec<Vec<u8>>

fee_rate: FeeRate

Implementations

impl SignableTransaction

fn input_keys_and_commitments(&self) -> Vec<(Point, Point)>

pub(crate) fn seeded_rng(&self, dst: &'static [u8]) -> ChaCha20Rng

fn has_payments_to_subaddresses(&self) -> bool

fn should_use_additional_keys(&self) -> bool

fn transaction_keys(&self) -> (Zeroizing<Scalar>, Vec<Zeroizing<Scalar>>)

fn ecdhs(&self) -> Vec<Zeroizing<Point>>

pub(crate) fn shared_key_derivations( &self, key_images: &[CompressedPoint], ) -> Vec<Zeroizing<SharedKeyDerivations>>

pub(crate) fn payment_id_xors(&self) -> Vec<[u8; 8]>

pub(crate) fn transaction_keys_pub(&self) -> (Point, Vec<CompressedPoint>)

pub(crate) fn commitments_and_encrypted_amounts( &self, key_images: &[CompressedPoint], ) -> Vec<(Commitment, EncryptedAmount)>

pub(crate) fn sum_output_masks(&self, key_images: &[CompressedPoint]) -> Scalar

impl SignableTransaction

pub(crate) fn inputs(&self, key_images: &[CompressedPoint]) -> Vec<Input>

pub(crate) fn outputs(&self, key_images: &[CompressedPoint]) -> Vec<Output>

pub(crate) fn extra(&self) -> Vec<u8>

pub(crate) fn weight_and_necessary_fee(&self) -> (usize, u64)

impl SignableTransaction

pub fn multisig( self, keys: ThresholdKeys<Ed25519>, ) -> Result<TransactionMachine, SendError>

Available on crate feature multisig only.

Create a FROST signing machine out of this signable transaction.

The created machine is expected to be called with an empty message, as it will generate its own, and may panic if a message is provided. The created machine DOES NOT support caching and may panic if cache, from_cache are called.

This function runs in time variable to the validity of the arguments and the public data.

impl SignableTransaction

fn validate(&self) -> Result<(), SendError>

pub fn new( rct_type: RctType, outgoing_view_key: Zeroizing<[u8; 32]>, inputs: Vec<OutputWithDecoys>, payments: Vec<(MoneroAddress, u64)>, change: Change, data: Vec<Vec<u8>>, fee_rate: FeeRate, ) -> Result<SignableTransaction, SendError>

Create a new SignableTransaction.

outgoing_view_key is used to seed the RNGs for this transaction. Anyone with knowledge of the outgoing view key will be able to identify a transaction produced with this methodology, and the data within it. Accordingly, it must be treated as a private key.

If one outgoing_view_key is reused across two transactions which share keys in their inputs, such transactions being mutually incompatible with each other on that premise, some ephemeral secrets MAY be reused causing adverse effects. Do NOT reuse an outgoing_view_key across incompatible transactions accordingly.

data represents arbitrary data which will be embedded into the transaction’s extra field. Please see Extra::arbitrary_data for the full impacts of this.

This will attempt to sign a transaction as constructed, even if the arguments are inconsistent or invalid for some view of the Monero network. It is the caller’s responsibility to ensure their sanity.

This function runs in time variable to the validity of the arguments and the public data.

pub fn fee_rate(&self) -> FeeRate

The fee rate this transaction uses.

pub fn necessary_fee(&self) -> u64

The fee this transaction requires.

This is distinct from the fee this transaction will use. If no change output is specified, all unspent coins will be shunted to the fee.

pub fn write<W: Write>(&self, w: &mut W) -> Result<()>

Write a SignableTransaction.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization. This may run in time variable to its value.

pub fn serialize(&self) -> Vec<u8>

Serialize the SignableTransaction to a Vec<u8>.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization. This may run in time variable to its value.

pub fn read<R: Read>(r: &mut R) -> Result<SignableTransaction>

Read a SignableTransaction.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization. This may run in time variable to its value.

fn with_key_images( self, key_images: Vec<CompressedPoint>, ) -> SignableTransactionWithKeyImages

pub fn unsigned_transaction( self, key_images: Vec<CompressedPoint>, ) -> Option<Transaction>

Fetch what the transaction will be, without its signatures (and associated fields).

This returns None if an improper amount of key images is provided.

pub fn sign( self, rng: &mut (impl RngCore + CryptoRng), sender_spend_key: &Zeroizing<Scalar>, ) -> Result<Transaction, SendError>

Sign this transaction.

This function runs in time variable to the validity of the arguments and the public data.

Trait Implementations

impl Clone for SignableTransaction

fn clone(&self) -> SignableTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignableTransaction

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

This Debug implementation may run in variable time and reveal everything except the outgoing_view_key.

impl Drop for SignableTransaction

fn drop(&mut self)

Executes the destructor for this type.

impl Eq for SignableTransaction

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl From<SignableTransaction> for Eventuality

fn from(tx: SignableTransaction) -> Eventuality

Converts to this type from the input type.

impl PartialEq for SignableTransaction

fn eq(&self, other: &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 Zeroize for SignableTransaction

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl ZeroizeOnDrop for SignableTransaction