Struct sn_dbc::Dbc

pub struct Dbc {
    pub id: DbcId,
    pub src_tx: DbcTransaction,
    pub secrets: DbcSecrets,
    pub signed_spends: BTreeSet<SignedSpend>,
}

Represents a Digital Bearer Certificate (Dbc).

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

A Dbc has a PublicAddress representing the recipient of the Dbc.

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

The PublicAddress can be given out to multiple parties and multiple Dbcs can share the same PublicAddress.

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

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

So, there are two important pairs to conceptually be aware of. The MainKey and PublicAddress is a unique pair of a user, where the MainKey is held secret, and the PublicAddress is given to all and anyone who wishes to send tokens to you. A sender of tokens will derive the DbcId from the PublicAddress, which will identify the Dbc 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 DerivedKey from the MainKey. The DerivedKey and DbcId pair is the second important pair. For an outsider, there is no way to associate either the DerivedKey or the DbcId to the PublicAddress (or for that matter to the MainKey, 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 Dbc, wallet software must obtain the corresponding MainKey from the user, and then call an API function that accepts a MainKey, eg: dbc.derivation_index(&main_key)

Fields

id: DbcId

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

src_tx: DbcTransaction

The transaction where this DBC was created.

secrets: DbcSecrets

Secret information for and about the recipient of this Dbc.

signed_spends: BTreeSet<SignedSpend>

The transaction’s input’s SignedSpends

Implementations

impl Dbc

pub fn id(&self) -> DbcId

Return the id of this Dbc.

pub fn public_address(&self) -> &PublicAddress

pub fn derived_key(&self, main_key: &MainKey) -> Result<DerivedKey>

Return DerivedKey using MainKey supplied by caller. Will return an error if the supplied MainKey does not match the Dbc PublicAddress.

pub fn derivation_index(&self) -> DerivationIndex

Return the derivation index that was used to derive DbcId and corresponding DerivedKey of a Dbc.

pub fn fee_output(&self) -> &FeeOutput

Return the fee output used in the source transaction

pub fn reason(&self) -> Hash

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

pub fn token(&self) -> Result<Token>

Return the Tokens for this Dbc.

pub fn hash(&self) -> Hash

Generate the hash of this Dbc

pub fn verify(&self, main_key: &MainKey) -> Result<(), Error>

Verifies that this Dbc is valid.

A Dbc 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 Dbc has been spent. For that, one must query the spentbook nodes.

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

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

Trait Implementations

impl Clone for Dbc

fn clone(&self) -> Dbc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Dbc

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

Formats the value using the given formatter.

impl PartialEq<Dbc> for Dbc

fn eq(&self, other: &Dbc) -> 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 Eq for Dbc

impl StructuralEq for Dbc

impl StructuralPartialEq for Dbc