Struct grin_wallet_libwallet::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: u64,
    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>,
    pub participant_id: Option<PublicKey>,
}

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: u64

fee amount

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 tranasction 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

participant_id: Option<PublicKey>

participant ID, only stored for compatibility with V3 slates not serialized anywhere

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 is_compact(&self) -> bool

Whether the slate started life as a compact slate

pub fn num_participants(&self) -> u8

number of participants

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 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 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,
    sec_key: &mut SecretKey,
    sec_nonce: &SecretKey,
    use_test_rng: bool
) -> Result<(), Error> where
    K: Keychain, 

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

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 add_participant_info<K>(
    &mut self,
    keychain: &K,
    sec_key: &SecretKey,
    sec_nonce: &SecretKey,
    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 generate_offset<K>(
    &mut self,
    keychain: &K,
    sec_key: &mut SecretKey,
    use_test_rng: bool
) -> Result<(), Error> where
    K: Keychain, 

Somebody involved needs to generate an offset with their private key For now, we'll have the transaction initiator be responsible for it Return offset private key for the participant to use later in the transaction

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 SlateV4

fn from(slate: &Slate) -> SlateV4

Performs the conversion.

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

fn from(slate: &Slate) -> Option<Vec<CommitsV4>>

Performs the conversion.

impl From<Slate> for SlateV4

fn from(slate: Slate) -> SlateV4

Performs the conversion.

impl From<SlateV4> for Slate

fn from(slate: SlateV4) -> Slate

Performs the conversion.

impl From<VersionedSlate> for Slate

fn from(slate: VersionedSlate) -> Slate

Performs the conversion.

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.