Struct sn_transfers::CashNote

pub struct CashNote {
    pub id: UniquePubkey,
    pub src_tx: Transaction,
    pub signed_spends: BTreeSet<SignedSpend>,
    pub main_pubkey: MainPubkey,
    pub derivation_index: DerivationIndex,
}

Types used in the public API Represents a CashNote (CashNote).

A CashNote is like a check. Only the recipient can spend it.

A CashNote has a MainPubkey representing the recipient of the CashNote.

An MainPubkey consists of a PublicKey. The user who receives payments to this MainPubkey, will be holding a MainSecretKey - a secret key, which corresponds to the MainPubkey.

The MainPubkey can be given out to multiple parties and multiple CashNotes can share the same MainPubkey.

The spentbook nodes never sees the MainPubkey. Instead, when a transaction output cashnote is created for a given MainPubkey, a random derivation index is generated and used to derive a UniquePubkey, which will be used for this new cashnote.

The UniquePubkey is a unique identifier of a CashNote. So there can only ever be one CashNote with that id, previously, now and forever. The UniquePubkey consists of a PublicKey. To unlock the tokens of the CashNote, the corresponding DerivedSecretKey (consists of a SecretKey) must be used. It is derived from the MainSecretKey, in the same way as the UniquePubkey was derived from the MainPubkey to get the UniquePubkey.

So, there are two important pairs to conceptually be aware of. The MainSecretKey and MainPubkey is a unique pair of a user, where the MainSecretKey is held secret, and the MainPubkey is given to all and anyone who wishes to send tokens to you. A sender of tokens will derive the UniquePubkey from the MainPubkey, which will identify the CashNote that holds the tokens going to the recipient. The sender does this using a derivation index. The recipient of the tokens, will use the same derivation index, to derive the DerivedSecretKey from the MainSecretKey. The DerivedSecretKey and UniquePubkey pair is the second important pair. For an outsider, there is no way to associate either the DerivedSecretKey or the UniquePubkey to the MainPubkey (or for that matter to the MainSecretKey, if they were ever to see it, which they shouldn’t of course). Only by having the derivation index, which is only known to sender and recipient, can such a connection be made.

To spend or work with a CashNote, wallet software must obtain the corresponding MainSecretKey from the user, and then call an API function that accepts a MainSecretKey, eg: cashnote.derivation_index(&main_key)

Fields

id: UniquePubkey

The unique pulbic key of this CashNote. It is unique, and there can never be another CashNote with the same pulbic key. It used in SignedSpends.

src_tx: Transaction

The transaction where this CashNote was created.

signed_spends: BTreeSet<SignedSpend>

The transaction’s input’s SignedSpends

main_pubkey: MainPubkey

This is the MainPubkey of the recipient of this CashNote.

derivation_index: DerivationIndex

This indicates which index to use when deriving the UniquePubkey of the CashNote, from the MainPubkey.

Implementations

impl CashNote

pub fn unique_pubkey(&self) -> UniquePubkey

Return the id of this CashNote.

pub fn main_pubkey(&self) -> &MainPubkey

pub fn derived_key(&self, main_key: &MainSecretKey) -> Result<DerivedSecretKey>

Return DerivedSecretKey using MainSecretKey supplied by caller. Will return an error if the supplied MainSecretKey does not match the CashNote MainPubkey.

pub fn derived_pubkey(&self, main_pubkey: &MainPubkey) -> Result<UniquePubkey>

Return UniquePubkey using MainPubkey supplied by caller. Will return an error if the supplied MainPubkey does not match the CashNote MainPubkey.

pub fn derivation_index(&self) -> DerivationIndex

Return the derivation index that was used to derive UniquePubkey and corresponding DerivedSecretKey of a CashNote.

pub fn reason(&self) -> Hash

Return the reason why this CashNote was spent. Will be the default Hash (empty) if reason is none.

pub fn value(&self) -> Result<NanoTokens>

Return the value in NanoTokens for this CashNote.

pub fn hash(&self) -> Hash

Generate the hash of this CashNote

pub fn verify(&self, main_key: &MainSecretKey) -> Result<(), TransferError>

Verifies that this CashNote is valid.

A CashNote recipient should call this immediately upon receipt.

important: this will verify there is a matching transaction provided for each SignedSpend, although this does not check if the CashNote has been spent. For that, one must query the spentbook nodes.

Note that the spentbook nodes cannot perform this check. Only the CashNote recipient (private key holder) can.

see TransactionVerifier::verify() for a description of verifier requirements.

pub fn from_hex(hex: &str) -> Result<Self, TransferError>

Deserializes a CashNote represented as a hex string to a CashNote.

pub fn to_hex(&self) -> Result<String, TransferError>

Serialize this CashNote instance to a hex string.

Trait Implementations

impl Clone for CashNote

fn clone(&self) -> CashNote

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CashNote

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CashNote

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CashNote

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CashNote

fn eq(&self, other: &CashNote) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CashNote

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CashNote

impl StructuralPartialEq for CashNote