Struct grin_wallet_impls::LMDBBackend

pub struct LMDBBackend<'ck, C, K>
where
    C: NodeClient + 'ck,
    K: Keychain + 'ck,
{
    pub keychain: Option<K>,
    pub master_checksum: Box<Option<Blake2bResult>>,
    /* private fields */
}

Fields

keychain: Option<K>

Keychain

master_checksum: Box<Option<Blake2bResult>>

Check value for XORed keychain seed

Implementations

impl<'ck, C, K> LMDBBackend<'ck, C, K>

where C: NodeClient + 'ck, K: Keychain + 'ck,

pub fn new(data_file_dir: &str, n_client: C) -> Result<Self, Error>

pub fn exists(data_file_dir: &str) -> bool

Just test to see if database files exist in the current directory. If so, use a DB backend for all operations

Trait Implementations

impl<'ck, C, K> WalletBackend<'ck, C, K> for LMDBBackend<'ck, C, K>

where C: NodeClient + 'ck, K: Keychain + 'ck,

fn set_keychain( &mut self, k: Box<K>, mask: bool, use_test_rng: bool ) -> Result<Option<SecretKey>, Error>

Set the keychain, which should already have been opened

fn close(&mut self) -> Result<(), Error>

Close wallet

fn keychain(&self, mask: Option<&SecretKey>) -> Result<K, Error>

Return the keychain being used, cloned with XORed token value for temporary use

fn w2n_client(&mut self) -> &mut C

Return the node client being used

fn calc_commit_for_cache( &mut self, keychain_mask: Option<&SecretKey>, amount: u64, id: &Identifier ) -> Result<Option<String>, Error>

return the version of the commit for caching

fn set_parent_key_id_by_name(&mut self, label: &str) -> Result<(), Error>

Set parent path by account name

fn set_parent_key_id(&mut self, id: Identifier)

set parent path

fn parent_key_id(&mut self) -> Identifier

return the parent path

fn get( &self, id: &Identifier, mmr_index: &Option<u64> ) -> Result<OutputData, Error>

Get output data by id

fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = OutputData> + 'a>

Iterate over all output data stored by the backend

fn get_tx_log_entry(&self, u: &Uuid) -> Result<Option<TxLogEntry>, Error>

Get an (Optional) tx log entry by uuid

fn tx_log_iter<'a>(&'a self) -> Box<dyn Iterator<Item = TxLogEntry> + 'a>

Iterate over all output data stored by the backend

fn get_private_context( &mut self, keychain_mask: Option<&SecretKey>, slate_id: &[u8] ) -> Result<Context, Error>

Retrieves the private context associated with a given slate id

fn acct_path_iter<'a>( &'a self ) -> Box<dyn Iterator<Item = AcctPathMapping> + 'a>

Iterate over all stored account paths

fn get_acct_path(&self, label: String) -> Result<Option<AcctPathMapping>, Error>

Gets an account path for a given label

fn store_tx(&self, uuid: &str, tx: &Transaction) -> Result<(), Error>

Stores a transaction

fn get_stored_tx(&self, uuid: &str) -> Result<Option<Transaction>, Error>

Retrieves a stored transaction from a TxLogEntry

fn batch<'a>( &'a mut self, keychain_mask: Option<&SecretKey> ) -> Result<Box<dyn WalletOutputBatch<K> + 'a>, Error>

Create a new write batch to update or remove output data

fn batch_no_mask<'a>( &'a mut self ) -> Result<Box<dyn WalletOutputBatch<K> + 'a>, Error>

Batch for use when keychain isn’t available or required

fn current_child_index<'a>( &mut self, parent_key_id: &Identifier ) -> Result<u32, Error>

Return the current child Index

fn next_child<'a>( &mut self, keychain_mask: Option<&SecretKey> ) -> Result<Identifier, Error>

Next child ID when we want to create a new output, based on current parent

fn last_confirmed_height<'a>(&mut self) -> Result<u64, Error>

last verified height of outputs directly descending from the given parent key

fn last_scanned_block<'a>(&mut self) -> Result<ScannedBlockInfo, Error>

last block scanned during scan or restore

fn init_status<'a>(&mut self) -> Result<WalletInitStatus, Error>

Flag whether the wallet needs a full UTXO scan on next update attempt