Struct TestDb 

pub struct TestDb { /* private fields */ }

Available on crate features test-dependencies only.

A WalletDb wrapped as a testing-framework data store: it delegates the wallet traits to the inner database and owns the temporary file backing it.

Implementations

impl TestDb

pub fn db(&self) -> &WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>

The wrapped wallet database.

pub fn db_mut( &mut self, ) -> &mut WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>

The wrapped wallet database, mutably.

pub fn conn(&self) -> &Connection

The wallet database’s own SQLite connection, over which a sibling store (a pool_migration store, say) is opened.

pub fn conn_mut(&mut self) -> &mut Connection

The wallet database’s own SQLite connection, mutably. See Self::conn.

Trait Implementations

impl InputSource for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: InputSource,

type Error = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as InputSource>::Error

The type of errors produced by a wallet backend.

type AccountId = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as InputSource>::AccountId

Backend-specific account identifier.

type NoteRef = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as InputSource>::NoteRef

Backend-specific note identifier.

fn get_spendable_note( &self, txid: &TxId, protocol: ShieldedPool, index: u32, target_height: TargetHeight, lock_filter: LockFilter<'_>, ) -> Result<Option<ReceivedNote<Self::NoteRef, Note>>, Self::Error>

Fetches a spendable note by indexing into a transaction’s shielded outputs for the specified shielded protocol.

fn anchor_computable( &self, protocol: ShieldedPool, height: BlockHeight, ) -> Result<bool, Self::Error>

Returns whether an anchor is COMPUTABLE at height for spends from the given pool: whether this data source can produce the note commitment tree root, and witnesses to it, as of the end of that block.

fn select_spendable_notes( &self, account: Self::AccountId, target_value: TargetValue, sources: &[ShieldedPool], target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, exclude: &[Self::NoteRef], lock_filter: LockFilter<'_>, ) -> Result<ReceivedNotes<Self::NoteRef>, Self::Error>

Returns a list of spendable notes sufficient to cover the specified target value, if possible. Only spendable notes corresponding to the specified shielded protocol will be included. Locked outputs are selected according to lock_filter (see LockFilter; a LockFilter::Policy carrying the default Exclude selects none).

fn select_single_spendable_note( &self, account: Self::AccountId, value: Zatoshis, sources: &[ShieldedPool], target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, exclude: &[Self::NoteRef], lock_filter: LockFilter<'_>, ) -> Result<ReceivedNotes<Self::NoteRef>, Self::Error>

Returns the OLDEST single spendable note whose value alone is at least value, drawn from the first pool in sources (in the given preference order) that holds one. The returned collection contains at most one note; it is empty when no single eligible note covers the value.

fn select_unspent_notes( &self, account: Self::AccountId, sources: &[ShieldedPool], target_height: TargetHeight, exclude: &[Self::NoteRef], lock_filter: LockFilter<'_>, ) -> Result<ReceivedNotes<Self::NoteRef>, Self::Error>

Returns the list of notes belonging to the wallet that are unspent as of the specified target height. Locked outputs are selected according to lock_filter (see LockFilter; a LockFilter::Policy carrying the default Exclude selects none).

fn get_account_metadata( &self, account: Self::AccountId, selector: &NoteFilter, target_height: TargetHeight, exclude: &[Self::NoteRef], lock_filter: LockFilter<'_>, ) -> Result<AccountMeta, Self::Error>

Returns metadata describing the structure of the wallet for the specified account.

fn get_unspent_transparent_output( &self, _outpoint: &OutPoint, _target_height: TargetHeight, ) -> Result<Option<WalletTransparentOutput<Self::AccountId>>, Self::Error>

Available on crate feature transparent-inputs only.

Fetches the transparent output corresponding to the provided outpoint if it is considered spendable as of the provided target_height.

fn get_spendable_transparent_outputs( &self, _address: &TransparentAddress, _target_height: TargetHeight, _confirmations_policy: ConfirmationsPolicy, _output_filter: CoinbaseFilter, _lock_filter: LockFilter<'_>, ) -> Result<Vec<WalletTransparentOutput<Self::AccountId>>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the list of unspent transparent outputs received by this wallet at address such that, at height target_height:

fn get_spendable_transparent_outputs_for_addresses( &self, addresses: &[TransparentAddress], target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, output_filter: CoinbaseFilter, lock_filter: LockFilter<'_>, ) -> Result<Vec<WalletTransparentOutput<Self::AccountId>>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the list of spendable transparent outputs received by this wallet at any of the given addresses, subject to the same spendability conditions as InputSource::get_spendable_transparent_outputs.

fn select_spendable_transparent_outputs( &self, account: Self::AccountId, target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, output_filter: CoinbaseFilter, address_allow_list: Option<&[TransparentAddress]>, target_value: TargetValue, max_inputs: usize, fee_rule: &StandardFeeRule, lock_filter: LockFilter<'_>, ) -> Result<Vec<WalletTransparentOutput<Self::AccountId>>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the spendable transparent outputs received by account whose total post-fee value (sum of values minus the cumulative marginal fee cost of the gathered inputs themselves, per fee_rule) is at least target_value, or max_inputs outputs (whichever is reached first).

impl OutputLockStore for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: OutputLockStore,

type Error = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as OutputLockStore>::Error

The type of errors produced by the lock store.

type AccountId = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as OutputLockStore>::AccountId

The type of the account identifier.

fn lock_outputs( &mut self, outputs: &[OutputRef], owner: LockOwner, lock_expiry_height: BlockHeight, ) -> Result<usize, LockError<Self::Error>>

Locks the specified outputs on behalf of owner so that, by default, they are not selected for spending at any height less than or equal to the given height.

fn unlock_output( &mut self, output: &OutputRef, owner: LockOwner, ) -> Result<bool, Self::Error>

Unlocks the specified output if it is locked by the given owner, making it once again available for spending and balance computations.

fn clear_locked_outputs( &mut self, account: Self::AccountId, ) -> Result<usize, Self::Error>

Unlocks every currently-locked output belonging to the specified account, regardless of lock expiry height.

fn get_locked_outputs( &self, account: Self::AccountId, ) -> Result<Vec<OutputRef>, Self::Error>

Returns the set of currently locked outputs for the given account.

impl Reset for TestDb

type Handle = Option<NamedTempFile>

A handle that confers ownership of a specific wallet instance.

fn reset<C>(st: &mut TestState<C, Self, LocalNetwork>) -> Self::Handle

Replaces the wallet in st (via TestState::wallet_mut) with a new wallet database.

impl WalletCommitmentTrees for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: WalletCommitmentTrees,

type Error = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletCommitmentTrees>::Error

type SaplingShardStore<'a> = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletCommitmentTrees>::SaplingShardStore<'a>

The type of the backing ShardStore for the Sapling note commitment tree.

fn with_sapling_tree_mut<F, A, E>(&mut self, callback: F) -> Result<A, E>

where for<'a> F: FnMut(&'a mut ShardTree<Self::SaplingShardStore<'a>, { sapling::NOTE_COMMITMENT_TREE_DEPTH }, SAPLING_SHARD_HEIGHT>) -> Result<A, E>, E: From<ShardTreeError<Self::Error>>,

Evaluates the given callback function with a reference to the Sapling note commitment tree maintained by the wallet.

fn put_sapling_subtree_roots( &mut self, start_index: u64, roots: &[CommitmentTreeRoot<Node>], ) -> Result<(), ShardTreeError<Self::Error>>

Adds a sequence of Sapling note commitment tree subtree roots to the data store.

fn get_sapling_subtree_root( &mut self, index: u64, ) -> Result<Option<Node>, ShardTreeError<Self::Error>>

Returns the stored root hash of the completed Sapling subtree with the given index, or Ok(None) if no root is recorded for that subtree.

fn put_sapling_shards( &mut self, shards: &[LocatedPrunableTree<Node>], cap: Option<&PrunableTree<Node>>, checkpoints_remove: &[BlockHeight], checkpoints_add: &[(BlockHeight, Checkpoint)], ) -> Result<(), ShardTreeError<Self::Error>>

Applies a batch of changes — shards, an optional replacement tree cap, and a checkpoint delta — to the wallet’s Sapling note commitment tree.

fn remove_retained_checkpoints_below( &mut self, max_height: BlockHeight, ) -> Result<(), ShardTreeError<Self::Error>>

Releases all retained (“anchor”) checkpoints with height strictly less than max_height from the wallet’s note commitment trees, allowing them to be pruned normally.

impl WalletRead for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: WalletRead,

type Error = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletRead>::Error

The type of errors that may be generated when querying a wallet data store.

type AccountId = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletRead>::AccountId

The type of the account identifier.

type Account = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletRead>::Account

The concrete account type used by this wallet backend.

fn get_account_ids(&self) -> Result<Vec<Self::AccountId>, Self::Error>

Returns a vector with the IDs of all accounts known to this wallet.

fn get_account( &self, account_id: Self::AccountId, ) -> Result<Option<Self::Account>, Self::Error>

Returns the account corresponding to the given ID, if any.

fn get_derived_account( &self, derivation: &Zip32Derivation, ) -> Result<Option<Self::Account>, Self::Error>

Returns the account corresponding to a given SeedFingerprint and zip32::AccountId, if any.

fn validate_seed( &self, account_id: Self::AccountId, seed: &SecretVec<u8>, ) -> Result<bool, Self::Error>

Verifies that the given seed corresponds to the viewing key for the specified account.

fn seed_relevance_to_derived_accounts( &self, seed: &SecretVec<u8>, ) -> Result<SeedRelevance<Self::AccountId>, Self::Error>

Checks whether the given seed is relevant to any of the derived accounts (where Account::source is AccountSource::Derived) in the wallet.

fn get_account_for_ufvk( &self, ufvk: &UnifiedFullViewingKey, ) -> Result<Option<Self::Account>, Self::Error>

Returns the account corresponding to a given UnifiedFullViewingKey, if any.

fn list_addresses( &self, account: Self::AccountId, ) -> Result<Vec<AddressInfo>, Self::Error>

Returns information about every address tracked for this account.

fn find_account_for_address<P: Parameters>( &self, params: &P, address: &Address, ) -> Result<Option<Self::AccountId>, FindAccountForAddressError<Self::Error>>

Returns the wallet account that controls the given address, if any.

fn get_last_generated_address_matching( &self, account: Self::AccountId, address_filter: UnifiedAddressRequest, ) -> Result<Option<UnifiedAddress>, Self::Error>

Returns the most recently generated unified address for the specified account that conforms to the specified address filter, if the account identifier specified refers to a valid account for this wallet.

fn get_account_birthday( &self, account: Self::AccountId, ) -> Result<BlockHeight, Self::Error>

Returns the birthday height for the given account, or an error if the account is not known to the wallet.

fn get_wallet_birthday(&self) -> Result<Option<BlockHeight>, Self::Error>

Returns the birthday height for the wallet.

fn get_wallet_recover_until(&self) -> Result<Option<BlockHeight>, Self::Error>

Returns the height at which the wallet as a whole will have exited recovery mode.

fn get_wallet_summary( &self, confirmations_policy: ConfirmationsPolicy, ) -> Result<Option<WalletSummary<Self::AccountId>>, Self::Error>

Returns a WalletSummary that represents the sync status and the wallet balances as of the chain tip given the specified confirmation policy for all accounts known to the wallet, or Ok(None) if the wallet has no summary data available.

fn chain_height(&self) -> Result<Option<BlockHeight>, Self::Error>

Returns the height of the chain as known to the wallet as of the most recent call to WalletWrite::update_chain_tip.

fn anchor_retention_interval(&self) -> AnchorRetentionInterval

Returns the interval on which this wallet retains note commitment tree checkpoints as durable anchors.

fn pool_migration_params(&self) -> PoolMigrationParams

Returns the ZIP 318 pool-migration parameters in force for this wallet: the specified values, with the anchor bucket grid taken from Self::anchor_retention_interval.

fn get_block_hash( &self, block_height: BlockHeight, ) -> Result<Option<BlockHash>, Self::Error>

Returns the block hash for the block at the given height, if the associated block data is available. Returns Ok(None) if the hash is not found in the database.

fn block_metadata( &self, height: BlockHeight, ) -> Result<Option<BlockMetadata>, Self::Error>

Returns the available block metadata for the block at the specified height, if any.

fn block_fully_scanned(&self) -> Result<Option<BlockMetadata>, Self::Error>

Returns the metadata for the block at the height to which the wallet has been fully scanned.

fn get_max_height_hash( &self, ) -> Result<Option<(BlockHeight, BlockHash)>, Self::Error>

Returns the block height and hash for the block at the maximum scanned block height.

fn block_max_scanned(&self) -> Result<Option<BlockMetadata>, Self::Error>

Returns block metadata for the maximum height that the wallet has scanned.

fn suggest_scan_ranges(&self) -> Result<Vec<ScanRange>, Self::Error>

Returns a vector of suggested scan ranges based upon the current wallet state.

fn get_target_and_anchor_heights( &self, min_confirmations: NonZeroU32, ) -> Result<Option<(TargetHeight, BlockHeight)>, Self::Error>

Returns the default target height (for the block in which a new transaction would be mined) and anchor height (to use for a new transaction), given the range of block heights that the backend knows about.

fn get_tx_height(&self, txid: TxId) -> Result<Option<BlockHeight>, Self::Error>

Returns the block height in which the specified transaction was mined, or Ok(None) if the transaction is not known to the wallet or not in the main chain.

fn get_unified_full_viewing_keys( &self, ) -> Result<HashMap<Self::AccountId, UnifiedFullViewingKey>, Self::Error>

Returns all unified full viewing keys known to this wallet.

fn get_memo(&self, note_id: NoteId) -> Result<Option<Memo>, Self::Error>

Returns the memo for a note.

fn get_transaction( &self, txid: TxId, ) -> Result<Option<Transaction>, Self::Error>

Returns the transaction with the given txid, if known to the wallet.

fn get_sapling_nullifiers( &self, query: NullifierQuery, ) -> Result<Vec<(Self::AccountId, Nullifier)>, Self::Error>

Returns the nullifiers for Sapling notes that the wallet is tracking, along with their associated account IDs, that are either unspent or have not yet been confirmed as spent (in that a spending transaction known to the wallet has not yet been included in a block).

fn get_transparent_receivers( &self, _account: Self::AccountId, _include_change: bool, _include_standalone: bool, ) -> Result<HashMap<TransparentAddress, TransparentAddressMetadata>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the set of non-ephemeral transparent receivers associated with the given account controlled by this wallet.

fn get_ephemeral_transparent_receivers( &self, _account: Self::AccountId, _exposure_depth: u32, _exclude_used: bool, ) -> Result<HashMap<TransparentAddress, TransparentAddressMetadata>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the set of previously-exposed ephemeral transparent receivers generated by the given account controlled by this wallet.

fn get_transparent_balances( &self, _account: Self::AccountId, _target_height: TargetHeight, _confirmations_policy: ConfirmationsPolicy, ) -> Result<TransparentBalances, Self::Error>

Available on crate feature transparent-inputs only.

Returns a mapping from each transparent receiver associated with the specified account to the key scope for that address and the balance of funds given the specified target height and confirmations policy.

fn get_transparent_address_metadata( &self, _account: Self::AccountId, _address: &TransparentAddress, ) -> Result<Option<TransparentAddressMetadata>, Self::Error>

Available on crate feature transparent-inputs only.

Returns the metadata associated with a given transparent receiver in an account controlled by this wallet, if available.

fn utxo_query_height( &self, _account: Self::AccountId, ) -> Result<BlockHeight, Self::Error>

Available on crate feature transparent-inputs only.

Returns the maximum block height at which a transparent output belonging to the wallet has been observed.

fn transaction_data_requests( &self, ) -> Result<Vec<TransactionDataRequest>, Self::Error>

Returns a vector of TransactionDataRequest values that describe information needed by the wallet to complete its view of transaction history.

fn get_received_outputs( &self, txid: TxId, target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, ) -> Result<Vec<ReceivedTransactionOutput>, Self::Error>

Returns a vector of ReceivedTransactionOutput values describing the outputs of the specified transaction that were received by the wallet. The number of confirmations until each received output will be considered spendable is determined based upon the specified target height and confirmations policy.

impl WalletTest for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: WalletTest,

fn get_tx_history( &self, ) -> Result<Vec<TransactionSummary<<Self as WalletRead>::AccountId>>, <Self as WalletRead>::Error>

Returns a vector of transaction summaries.

fn get_sent_note_ids( &self, _txid: &TxId, _protocol: ShieldedPool, ) -> Result<Vec<NoteId>, <Self as WalletRead>::Error>

Returns the note IDs for shielded notes sent by the wallet in a particular transaction.

fn get_sent_outputs( &self, txid: &TxId, ) -> Result<Vec<OutputOfSentTx>, <Self as WalletRead>::Error>

Returns the outputs for a transaction sent by the wallet.

fn get_checkpoint_history( &self, protocol: &ShieldedPool, ) -> Result<Vec<(BlockHeight, Option<Position>)>, <Self as WalletRead>::Error>

fn get_transparent_output( &self, _outpoint: &OutPoint, _spendable_as_of: Option<TargetHeight>, ) -> Result<Option<WalletTransparentOutput<<Self as WalletRead>::AccountId>>, <Self as InputSource>::Error>

Available on crate feature transparent-inputs only.

Fetches the transparent output corresponding to the provided outpoint. Allows selecting unspendable outputs for testing purposes.

fn get_notes( &self, protocol: ShieldedPool, ) -> Result<Vec<ReceivedNote<Self::NoteRef, Note>>, <Self as InputSource>::Error>

Returns all the notes that have been received by the wallet.

fn get_known_ephemeral_addresses( &self, _account: <Self as WalletRead>::AccountId, _index_range: Option<Range<NonHardenedChildIndex>>, ) -> Result<Vec<(TransparentAddress, TransparentAddressMetadata)>, <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Returns a vector of ephemeral transparent addresses associated with the given account controlled by this wallet, along with their metadata. The result includes reserved addresses, and addresses for the backend’s configured gap limit worth of additional indices (capped to the maximum index).

fn find_account_for_ephemeral_address( &self, address: &TransparentAddress, ) -> Result<Option<<Self as WalletRead>::AccountId>, <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

If a given ephemeral address might have been reserved, i.e. would be included in the result of get_known_ephemeral_addresses(account_id, None) for any of the wallet’s accounts, then return Ok(Some(account_id)). Otherwise return Ok(None).

fn finally(&self)

Performs final checks at the conclusion of each test.

impl WalletWrite for TestDb

where WalletDb<Connection, LocalNetwork, FixedClock, ChaChaRng>: WalletWrite,

type UtxoRef = <WalletDb<Connection, LocalNetwork, FixedClock, ChaCha20Rng> as WalletWrite>::UtxoRef

The type of identifiers used to look up transparent UTXOs.

fn create_account( &mut self, account_name: &str, seed: &SecretVec<u8>, birthday: &AccountBirthday, key_source: Option<&str>, ) -> Result<(<Self as WalletRead>::AccountId, UnifiedSpendingKey), <Self as WalletRead>::Error>

Tells the wallet to track the next available account-level spend authority for the provided seed value, given the current set of ZIP 316 account identifiers known to the wallet database.

fn import_account_hd( &mut self, account_name: &str, seed: &SecretVec<u8>, account_index: AccountId, birthday: &AccountBirthday, key_source: Option<&str>, ) -> Result<(Self::Account, UnifiedSpendingKey), <Self as WalletRead>::Error>

Tells the wallet to track a specific account index for a given seed.

fn import_account_ufvk( &mut self, account_name: &str, unified_key: &UnifiedFullViewingKey, birthday: &AccountBirthday, purpose: AccountPurpose, key_source: Option<&str>, ) -> Result<Self::Account, <Self as WalletRead>::Error>

Tells the wallet to track an account using a unified full viewing key.

fn delete_account( &mut self, account: <Self as WalletRead>::AccountId, ) -> Result<(), <Self as WalletRead>::Error>

Deletes the specified account, and all transactions that exclusively involve it, from the wallet database.

fn get_next_available_address( &mut self, account: <Self as WalletRead>::AccountId, request: UnifiedAddressRequest, ) -> Result<Option<(UnifiedAddress, DiversifierIndex)>, <Self as WalletRead>::Error>

Generates, persists, and marks as exposed the next available diversified address for the specified account, given the current addresses known to the wallet.

fn get_address_for_index( &mut self, account: <Self as WalletRead>::AccountId, diversifier_index: DiversifierIndex, request: UnifiedAddressRequest, ) -> Result<Option<UnifiedAddress>, <Self as WalletRead>::Error>

Generates, persists, and marks as exposed a diversified address for the specified account at the provided diversifier index.

fn update_chain_tip( &mut self, tip_height: BlockHeight, ) -> Result<(), <Self as WalletRead>::Error>

Updates the wallet’s view of the blockchain.

fn prune_scan_queue_below( &mut self, height: BlockHeight, retain_with_priority: Option<ScanPriority>, ) -> Result<u64, <Self as WalletRead>::Error>

Drops the scan work queued below height, except where retained by retain_with_priority. Returns the number of queue entries removed or altered.

fn put_blocks( &mut self, from_state: &ChainState, blocks: Vec<ScannedBlock<<Self as WalletRead>::AccountId>>, ) -> Result<(), <Self as WalletRead>::Error>

Updates the state of the wallet database by persisting the provided block information, along with the note commitments that were detected when scanning the block for transactions pertaining to this wallet.

fn put_received_transparent_utxo( &mut self, output: &WalletTransparentOutput<<Self as WalletRead>::AccountId>, ) -> Result<Self::UtxoRef, <Self as WalletRead>::Error>

Adds a transparent UTXO received by the wallet to the data store.

fn store_decrypted_tx( &mut self, received_tx: DecryptedTransaction<'_, Transaction, <Self as WalletRead>::AccountId>, ) -> Result<(), <Self as WalletRead>::Error>

Caches a decrypted transaction in the persistent wallet store.

fn set_tx_trust( &mut self, txid: TxId, trusted: bool, ) -> Result<(), <Self as WalletRead>::Error>

Sets the trust status of the given transaction to either trusted or untrusted.

fn store_transactions_to_be_sent( &mut self, transactions: &[SentTransaction<'_, <Self as WalletRead>::AccountId>], ) -> Result<(), <Self as WalletRead>::Error>

Saves information about transactions constructed by the wallet to the persistent wallet store.

fn truncate_to_height( &mut self, max_height: BlockHeight, ) -> Result<BlockHeight, <Self as WalletRead>::Error>

Truncates the wallet database to at most the specified height.

fn truncate_to_chain_state( &mut self, chain_state: ChainState, ) -> Result<(), <Self as WalletRead>::Error>

Truncates the wallet database to the specified chain state.

fn rewind_to_chain_state( &mut self, chain_state: ChainState, reset_account_birthdays: HashSet<<Self as WalletRead>::AccountId>, ) -> Result<(), RewindError<<Self as WalletRead>::AccountId, <Self as WalletRead>::Error>>

Rewinds the wallet to the specified chain state, preserving wallet data which has been confirmed beyond the pruning depth, and lowering the birthday height of selected accounts to the block following the chain state.

fn reserve_next_n_ephemeral_addresses( &mut self, _account_id: <Self as WalletRead>::AccountId, _n: usize, ) -> Result<Vec<(TransparentAddress, TransparentAddressMetadata)>, <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Reserves the next n available ephemeral addresses for the given account. This cannot be undone, so as far as possible, errors associated with transaction construction should have been reported before calling this method.

fn reserve_next_n_internal_addresses( &mut self, _account_id: <Self as WalletRead>::AccountId, _n: usize, ) -> Result<Vec<(TransparentAddress, TransparentAddressMetadata)>, <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Reserves the next n available internal-scope (change) transparent addresses for the given account, as described in BIP 44 under the change path level. This cannot be undone, so as far as possible, errors associated with transaction construction should have been reported before calling this method.

fn set_transaction_status( &mut self, _txid: TxId, _status: TransactionStatus, ) -> Result<(), <Self as WalletRead>::Error>

Updates the wallet backend with respect to the status of a specific transaction, from the perspective of the main chain.

fn schedule_next_check( &mut self, _address: &TransparentAddress, _offset_seconds: u32, ) -> Result<Option<SystemTime>, <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Schedules a UTXO check for the given address at a random time that has an expected value of offset_seconds from the current system time.

fn mark_transparent_addresses_exposed( &mut self, _exposures: &[(TransparentAddress, BlockHeight)], ) -> Result<(), <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Informs the wallet backend that the given transparent addresses are known to have been exposed externally at or before the block height paired with each address.

fn notify_address_checked( &mut self, _request: TransactionsInvolvingAddress, _as_of_height: BlockHeight, ) -> Result<(), <Self as WalletRead>::Error>

Available on crate feature transparent-inputs only.

Notifies the wallet backend that the given query for transactions involving a particular address has completed evaluation.