Struct MintRecoveryStateV2

pub struct MintRecoveryStateV2 {
    spendable_notes: BTreeMap<Nonce, (Amount, SpendableNote)>,
    pending_outputs: BTreeMap<Nonce, (OutPoint, Amount, NoteIssuanceRequest)>,
    pending_nonces: BTreeMap<CompressedBlindedMessage, (NoteIssuanceRequest, NoteIndex, Amount)>,
    used_nonces: BTreeMap<CompressedBlindedMessage, (NoteIssuanceRequest, NoteIndex, Amount)>,
    reused_note_indices: Vec<(Amount, NoteIndex)>,
    burned_total: Amount,
    next_pending_note_idx: Tiered<NoteIndex>,
    last_used_nonce_idx: Tiered<NoteIndex>,
    threshold: u64,
    pub_key_shares: BTreeMap<PeerId, Tiered<PublicKeyShare>>,
    tbs_pks: Tiered<AggregatePublicKey>,
    gap_limit: u64,
}

The state machine used for fast-forwarding backup from point when it was taken to the present time by following epoch history items from the time the snapshot was taken.

The caller is responsible for creating it, and then feeding it in order all valid consensus items from the epoch history between time taken (or even somewhat before it) and present time.

Fields

spendable_notes: BTreeMap<Nonce, (Amount, SpendableNote)>

pending_outputs: BTreeMap<Nonce, (OutPoint, Amount, NoteIssuanceRequest)>

Nonces that we track that are currently spendable.

pending_nonces: BTreeMap<CompressedBlindedMessage, (NoteIssuanceRequest, NoteIndex, Amount)>

Next nonces that we expect might soon get used. Once we see them, we move the tracking to pending_outputs

Note: since looking up nonces is going to be the most common operation the pool is kept shared (so only one lookup is enough), and replenishment is done each time a note is consumed.

used_nonces: BTreeMap<CompressedBlindedMessage, (NoteIssuanceRequest, NoteIndex, Amount)>

Nonces that we have already used. Used for detecting double-used nonces (accidentally burning funds).

reused_note_indices: Vec<(Amount, NoteIndex)>

Note indices that were reused.

burned_total: Amount

Total amount probably burned due to re-using nonces

next_pending_note_idx: Tiered<NoteIndex>

Tail of pending. pending_notes is filled by generating note with this index and incrementing it.

last_used_nonce_idx: Tiered<NoteIndex>

LastECashNoteIndex but tracked in flight. Basically max index of any note that got a partial sig from the federation (initialled from the backup value). TODO: One could imagine a case where the note was issued but not get any partial sigs yet. Very unlikely in real life scenario, but worth considering.

threshold: u64

Threshold

pub_key_shares: BTreeMap<PeerId, Tiered<PublicKeyShare>>

Public key shares for each peer

Used to validate contributed consensus items

tbs_pks: Tiered<AggregatePublicKey>

Aggregate public key for each amount tier

gap_limit: u64

The number of nonces we look-ahead when looking for mints (per each amount).

Implementations

impl MintRecoveryStateV2

pub fn from_backup( backup: EcashBackupV0, gap_limit: u64, tbs_pks: Tiered<AggregatePublicKey>, pub_key_shares: BTreeMap<PeerId, Tiered<PublicKeyShare>>, secret: &DerivableSecret, ) -> Self

fn fill_initial_pending_nonces( &mut self, amount: Amount, secret: &DerivableSecret, )

Fill each tier pool to the gap limit

fn add_next_pending_nonce_in_pending_pool( &mut self, amount: Amount, secret: &DerivableSecret, )

Add next nonce from amount tier to the next_pending_note_idx

pub fn handle_input(&mut self, input: &MintInput)

pub fn handle_output( &mut self, out_point: OutPoint, output: &MintOutput, secret: &DerivableSecret, )

fn observe_nonce_idx_being_used( &mut self, amount: Amount, note_idx: NoteIndex, secret: &DerivableSecret, )

React to a valid pending nonce being tracked being used in the epoch history

(Possibly) increment the self.last_mined_nonce_idx, then replenish the pending pool to always maintain at least gap_limit of pending nonces in each amount tier.

pub fn finalize(self) -> EcashRecoveryFinalState

Trait Implementations

impl Clone for MintRecoveryStateV2

fn clone(&self) -> MintRecoveryStateV2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MintRecoveryStateV2

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

Formats the value using the given formatter.

impl Decodable for MintRecoveryStateV2

fn consensus_decode_from_finite_reader<D: Read>( d: &mut D, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode Self from a size-limited reader.

fn consensus_decode_whole( slice: &[u8], modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

fn consensus_decode<R>( r: &mut R, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

where R: Read,

Decode an object with a well-defined format.

fn consensus_decode_hex( hex: &str, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

Decode an object from hex

fn consensus_decode_vec( bytes: Vec<u8>, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

impl<'de> Deserialize<'de> for MintRecoveryStateV2

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for MintRecoveryStateV2

fn consensus_encode<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

Encode an object with a well-defined format. Returns the number of bytes written on success.

fn consensus_encode_to_vec(&self) -> Vec<u8>

Self::consensus_encode to newly allocated Vec<u8>

fn consensus_encode_to_hex(&self) -> String

Encode and convert to hex string representation

fn consensus_encode_to_len(&self) -> usize

Encode without storing the encoding, return the size

fn consensus_hash<H>(&self) -> H

where H: Hash, <H as Hash>::Engine: Write,

Generate a SHA256 hash of the consensus encoding using the default hash engine for H.

fn consensus_hash_sha256(&self) -> Hash

Self::consensus_hash for [bitcoin::hashes::sha256::Hash]

impl PartialEq for MintRecoveryStateV2

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

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 MintRecoveryStateV2

impl StructuralPartialEq for MintRecoveryStateV2