Struct Slate

pub struct Slate {

    pub version_info: VersionCompatInfo,
    pub num_participants: u8,
    pub id: Uuid,
    pub state: SlateState,
    pub tx: Option<Transaction>,
    pub amount: u64,
    pub fee_fields: FeeFields,
    pub ttl_cutoff_height: u64,
    pub kernel_features: u8,
    pub offset: BlindingFactor,
    pub participant_data: Vec<ParticipantData>,
    pub payment_proof: Option<PaymentInfo>,
    pub kernel_features_args: Option<KernelFeaturesArgs>,
}

A ‘Slate’ is passed around to all parties to build up all of the public transaction data needed to create a finalized transaction. Callers can pass the slate around by whatever means they choose, (but we can provide some binary or JSON serialization helpers here).

Fields

version_info: VersionCompatInfo

Versioning info

num_participants: u8

The number of participants intended to take part in this transaction

id: Uuid

Unique transaction ID, selected by sender

state: SlateState

Slate state

tx: Option<Transaction>

The core transaction data: inputs, outputs, kernels, kernel offset Optional as of V4 to allow for a compact transaction initiation

amount: u64

base amount (excluding fee)

fee_fields: FeeFields

fee amount and shift

ttl_cutoff_height: u64

TTL, the block height at which wallets should refuse to process the transaction and unlock all associated outputs

kernel_features: u8

Kernel Features flag - 0: plain 1: coinbase (invalid) 2: height_locked 3: NRD

offset: BlindingFactor

Offset, needed when posting of transasction is deferred

participant_data: Vec<ParticipantData>

Participant data, each participant in the transaction will insert their public data here. For now, 0 is sender and 1 is receiver, though this will change for multi-party

payment_proof: Option<PaymentInfo>

Payment Proof

kernel_features_args: Option<KernelFeaturesArgs>

Kernel features arguments

Implementations

impl Slate

pub fn tx_or_err(&self) -> Result<&Transaction, Error>

Return the transaction, throwing an error if it doesn’t exist to be used at points in the code where the existence of a transaction is assumed

pub fn tx_or_err_mut(&mut self) -> Result<&mut Transaction, Error>

As above, but return mutable reference

pub fn num_participants(&self) -> u8

number of participants

pub fn deserialize_upgrade(slate_json: &str) -> Result<Slate, Error>

Recieve a slate, upgrade it to the latest version internally Throw error if this can’t be done

pub fn upgrade(v_slate: VersionedSlate) -> Result<Slate, Error>

Upgrade a versioned slate

pub fn compact(&mut self) -> Result<(), Error>

Compact the slate for initial sending, storing the excess + offset explicit and removing my input/output data This info must be stored in the context for repopulation later

pub fn empty_transaction() -> Transaction

Build a new empty transaction. Wallet currently only supports tx with “features and commit” inputs.

pub fn blank(num_participants: u8, is_invoice: bool) -> Slate

Create a new slate

pub fn remove_other_sigdata<K>( &mut self, keychain: &K, sec_nonce: &SecretKey, sec_key: &SecretKey, ) -> Result<(), Error>

where K: Keychain,

Removes any signature data that isn’t mine, for compacting slates for a return journey

pub fn add_transaction_elements<K, B>( &mut self, keychain: &K, builder: &B, elems: Vec<Box<Append<K, B>>>, ) -> Result<BlindingFactor, Error>

where K: Keychain, B: ProofBuild,

Adds selected inputs and outputs to the slate’s transaction Returns blinding factor

pub fn update_kernel(&mut self) -> Result<(), Error>

Update the tx kernel based on kernel features derived from the current slate. The fee may change as we build a transaction and we need to update the tx kernel to reflect this during the tx building process.

pub fn fill_round_1<K>( &mut self, keychain: &K, context: &mut Context, ) -> Result<(), Error>

where K: Keychain,

Completes callers part of round 1, adding public key info to the slate

pub fn msg_to_sign(&self) -> Result<Message, Error>

This is the msg that we will sign as part of the tx kernel.

pub fn fill_round_2<K>( &mut self, keychain: &K, sec_key: &SecretKey, sec_nonce: &SecretKey, ) -> Result<(), Error>

where K: Keychain,

Completes caller’s part of round 2, completing signatures

pub fn finalize<K>(&mut self, keychain: &K) -> Result<(), Error>

where K: Keychain,

Creates the final signature, callable by either the sender or recipient (after phase 3: sender confirmation)

pub fn pub_nonce_sum(&self, secp: &Secp256k1) -> Result<PublicKey, Error>

Return the sum of public nonces

pub fn pub_blind_sum(&self, secp: &Secp256k1) -> Result<PublicKey, Error>

Return the sum of public blinding factors

pub fn add_participant_info<K>( &mut self, keychain: &K, context: &Context, part_sig: Option<Signature>, ) -> Result<(), Error>

where K: Keychain,

Adds participants public keys to the slate data and saves participant’s transaction context sec_key can be overridden to replace the blinding factor (by whoever split the offset)

pub fn adjust_offset<K: Keychain>( &mut self, keychain: &K, context: &Context, ) -> Result<(), Error>

Add our contribution to the offset based on the excess, inputs and outputs

pub fn calc_excess(&self, secp: &Secp256k1) -> Result<Commitment, Error>

Calculate the excess

Trait Implementations

impl Clone for Slate

fn clone(&self) -> Slate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Slate

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

Formats the value using the given formatter.

impl Display for Slate

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

Formats the value using the given formatter.

impl From<&Slate> for Option<Vec<CommitsV4>>

fn from(slate: &Slate) -> Self

Converts to this type from the input type.

impl From<&Slate> for SlateV4

fn from(slate: &Slate) -> SlateV4

Converts to this type from the input type.

impl From<Slate> for SlateV4

fn from(slate: Slate) -> SlateV4

Converts to this type from the input type.

impl From<SlateV4> for Slate

fn from(slate: SlateV4) -> Slate

Converts to this type from the input type.

impl From<VersionedSlate> for Slate

fn from(slate: VersionedSlate) -> Slate

Converts to this type from the input type.

impl Serialize for Slate

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.