Struct MintRecovery 

pub struct MintRecovery {
    state: MintRecoveryStateV2,
    secret: DerivableSecret,
    client_ctx: ClientContext<MintClientModule>,
}

Fields

state: MintRecoveryStateV2

secret: DerivableSecret

client_ctx: ClientContext<MintClientModule>

Trait Implementations

impl Clone for MintRecovery

fn clone(&self) -> MintRecovery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MintRecovery

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

Formats the value using the given formatter.

impl RecoveryFromHistory for MintRecovery

fn finalize_dbtx<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle session outcome, adjusting the current state

type Init = MintClientInit

ClientModuleInit of this recovery logic.

fn new<'life0, 'life1, 'life2, 'async_trait>( _init: &'life0 Self::Init, args: &'life1 ClientModuleRecoverArgs<Self::Init>, snapshot: Option<&'life2 EcashBackup>, ) -> Pin<Box<dyn Future<Output = Result<(Self, u64)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

New empty state to start recovery from, and session number to start from

fn load_dbtx<'life0, 'life1, 'life2, 'life3, 'async_trait>( _init: &'life0 Self::Init, dbtx: &'life1 mut DatabaseTransaction<'life2>, args: &'life3 ClientModuleRecoverArgs<Self::Init>, ) -> Pin<Box<dyn Future<Output = Result<Option<(Self, RecoveryFromHistoryCommon)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Try to load the existing state previously stored with RecoveryFromHistory::store_dbtx.

fn store_dbtx<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, common: &'life3 RecoveryFromHistoryCommon, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store the current recovery state in the database

fn delete_dbtx<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete the recovery state from the database

fn load_finalized<'life0, 'life1, 'async_trait>( dbtx: &'life0 mut DatabaseTransaction<'life1>, ) -> Pin<Box<dyn Future<Output = Option<bool>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

Read the finalization status

fn store_finalized<'life0, 'life1, 'async_trait>( dbtx: &'life0 mut DatabaseTransaction<'life1>, state: bool, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

Store finalization status

fn handle_input<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _client_ctx: &'life1 ClientContext<MintClientModule>, _idx: usize, input: &'life2 MintInput, _session_idx: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle transaction input, adjusting the current state

fn handle_output<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _client_ctx: &'life1 ClientContext<MintClientModule>, out_point: OutPoint, output: &'life2 MintOutput, _session_idx: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle transaction output, adjusting the current state

fn handle_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, client_ctx: &'life1 ClientContext<<Self::Init as ClientModuleInit>::Module>, session_idx: u64, session_items: &'life2 Vec<AcceptedItem>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Handle session outcome, adjusting the current state

fn handle_transaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, client_ctx: &'life1 ClientContext<<Self::Init as ClientModuleInit>::Module>, transaction: &'life2 Transaction, session_idx: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Handle session outcome, adjusting the current state

fn pre_finalize<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Send + 'async_trait,

Called before finalize_dbtx, to allow final state changes outside of retriable database transaction.