Struct WalletRecovery

pub struct WalletRecovery {
    state: WalletRecoveryStateV1,
    data: WalletClientModuleData,
    btc_rpc: DynBitcoindRpc,
}

Wallet client module recovery implementation

First, history of Federation is scanned for expected peg-in addresses being used to find any peg-ins in a perfectly private way.

Then from that point (TweakIdx) Bitcoin node is queried for any peg-ins that might have happened on chain, but not were claimed yet, up to a certain gap limit.

Eventually last known used TweakIdx is moved a bit forward, and that’s the new point a client will use for new peg-ins.

Fields

state: WalletRecoveryStateV1

data: WalletClientModuleData

btc_rpc: DynBitcoindRpc

Trait Implementations

impl Clone for WalletRecovery

fn clone(&self) -> WalletRecovery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WalletRecovery

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

Formats the value using the given formatter.

impl RecoveryFromHistory for WalletRecovery

type Init = WalletClientInit

ClientModuleInit of this recovery logic.

fn new<'life0, 'life1, 'life2, 'async_trait>( init: &'life0 WalletClientInit, args: &'life1 ClientModuleRecoverArgs<Self::Init>, snapshot: Option<&'life2 WalletModuleBackup>, ) -> 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 WalletClientInit, 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<WalletClientModule>, _idx: usize, input: &'life2 WalletInput, 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 pre_finalize<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

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

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,

Finalize the recovery converting the tracked state to final changes in the database.

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 handle_output<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _client_ctx: &'life1 ClientContext<<Self::Init as ClientModuleInit>::Module>, _out_point: OutPoint, _output: &'life2 <<<Self::Init as ClientModuleInit>::Module as ClientModule>::Common as ModuleCommon>::Output, _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 transaction output, adjusting the current state