Struct WalletDb 

pub struct WalletDb<C, P, CL, R> { /* private fields */ }

A wrapper for the SQLite connection to the wallet database, along with a capability to read the system from the clock. A WalletDb encapsulates the full set of capabilities that are required in order to implement the WalletRead, WalletWrite and WalletCommitmentTrees traits.

Implementations

impl<C, P, CL, R> WalletDb<C, P, CL, R>

pub fn params(&self) -> &P

Returns the network parameters that this walletdb instance is bound to.

impl<P, CL, R> WalletDb<Connection, P, CL, R>

pub fn for_path<F: AsRef<Path>>( path: F, params: P, clock: CL, rng: R, ) -> Result<Self, Error>

Construct a WalletDb instance that connects to the wallet database stored at the specified path.

Parameters

• path: The path to the SQLite database used to store wallet data.
• params: Parameters associated with the Zcash network that the wallet will connect to.
• clock: The clock to use in the case that the backend needs access to the system time.
• rng: The random number generation capability to be exposed by the created WalletDb instance.

impl<C, P, CL, R> WalletDb<C, P, CL, R>

pub fn with_anchor_retention_interval( self, interval: AnchorRetentionInterval, ) -> Self

Sets the interval on which this wallet retains note commitment tree checkpoints as durable anchors, exempt from ordinary checkpoint pruning.

A ZIP 318 pool migration planned over this wallet reads the interval back through WalletRead::anchor_retention_interval and draws its transfers’ anchors from the same grid, so the two cannot disagree.

This setting is not persisted, but it does not need to be: once a migration is committed, the grid it was committed under is recorded with it, and this wallet keeps retaining that grid’s boundaries for as long as the migration is in flight, whatever it is currently configured with. Reopening the wallet without reapplying a non-default interval therefore cannot strand an in-flight migration; it only affects what grid the NEXT migration is planned against.

The default is AnchorRetentionInterval::ZIP_318, which every wallet on the production network must use.

pub fn set_anchor_retention_interval( &mut self, interval: AnchorRetentionInterval, )

Sets the anchor retention interval on an existing handle; see Self::with_anchor_retention_interval, of which this is the by-reference form.

impl<C, P, CL, R> WalletDb<C, P, CL, R>

pub fn with_gap_limits(self, gap_limits: GapLimits) -> Self

Available on crate feature transparent-inputs only.

Sets the gap limits to be used by the wallet in transparent address generation.

impl<C: Borrow<Connection>, P, CL, R> WalletDb<C, P, CL, R>

pub fn from_connection(conn: C, params: P, clock: CL, rng: R) -> Self

Constructs a new wrapper around the given connection.

This is provided for use cases such as connection pooling, where conn may be an &mut rusqlite::Connection.

The caller must ensure that rusqlite::vtab::array::load_module has been called on the connection.

Parameters

• conn: A connection to the wallet database.
• params: Parameters associated with the Zcash network that the wallet will connect to.
• clock: The clock to use in the case that the backend needs access to the system time.
• rng: The random number generation capability to be exposed by the created WalletDb instance.

impl<C: BorrowMut<Connection>, P, CL, R> WalletDb<C, P, CL, R>

pub fn transactionally<F, A, E: From<Error>>(&mut self, f: F) -> Result<A, E>

where F: FnOnce(&mut WalletDb<SqlTransaction<'_>, &P, &CL, &mut R>) -> Result<A, E>,

Performs several wallet database operations atomically.

This has two main uses:

• Ensuring that several WalletRead and/or WalletWrite operations either all succeed, or nothing happens. If an error occurs inside the given function, any operations completed by it are rolled back.
• Amortizing the cost of database transactionality. If several identical operations are planned in sequence (e.g. WalletWrite::store_decrypted_tx), this function can be used to avoid the overhead of a separate database transaction per insert.

pub fn transactionally_with_extension<F, A, E: From<Error>>( &mut self, f: F, ) -> Result<A, E>

where F: FnOnce(&mut WalletDb<SqlTransaction<'_>, &P, &CL, &mut R>, &ExtensionTransaction<'_>) -> Result<A, E>,

Performs wallet database operations and writes to application-owned extension tables atomically within a single database transaction.

This behaves like WalletDb::transactionally, but additionally provides an ExtensionTransaction handle sharing the same transaction. This allows an application to pair a wallet operation (such as importing an account) with writes to its own tables created via WalletMigrator::with_external_migrations, so that either both take effect or neither does.

The extension handle restricts the statements it will execute; see ExtensionTransaction for the exact authorization policy. In particular, writes are permitted only against tables whose names begin with the ext_ prefix.

Examples

wallet_db.transactionally_with_extension(|wdb, ext| {
    let account = wdb.import_account_ufvk(
        "external account",
        &ufvk,
        &birthday,
        AccountPurpose::ViewOnly,
        None,
    )?;
    ext.execute(
        "INSERT INTO ext_myapp_accounts (account_uuid, label) VALUES (?1, ?2)",
        (account.id().expose_uuid(), "external account"),
    )?;
    Ok::<_, SqliteClientError>(account)
})?;

pub fn check_witnesses( &mut self, ) -> Result<Vec<Range<BlockHeight>>, SqliteClientError>

Attempts to construct a witness for each note belonging to the wallet that is believed by the wallet to currently be spendable, and returns a vector of the ranges that must be rescanned in order to correct missing witness data.

This method is intended for repairing wallets that broke due to bugs in shardtree.

pub fn queue_rescans( &mut self, rescan_ranges: NonEmpty<Range<BlockHeight>>, priority: ScanPriority, ) -> Result<(), SqliteClientError>

Updates the scan queue by inserting scan ranges for the given range of block heights, with the specified scanning priority.

impl<C: BorrowMut<Connection>, P, CL: Clock, R: RngCore> WalletDb<C, P, CL, R>

pub fn schedule_ephemeral_address_checks( &mut self, ) -> Result<(), SqliteClientError>

Available on crate feature transparent-inputs only.

For each ephemeral address in the wallet, ensure that the transaction data request queue contains a request for the wallet to check for UTXOs belonging to that address at some time during the next 24-hour period.

We use randomized scheduling of ephemeral address checks to ensure that a lightwalletd-compromising adversary cannot use temporal clustering to determine what ephemeral addresses belong to a given wallet.

Trait Implementations

impl<'a, C: Borrow<Transaction<'a>>, P: Parameters, CL: Clock, R: RngCore> AddressStore for WalletDb<C, P, CL, R>

Available on crate feature transparent-inputs only.

type Error = SqliteClientError

The type of errors produced by the wallet storage backend.

type AccountRef = AccountRef

A wallet-internal account identifier.

fn find_gap_start( &self, account_ref: Self::AccountRef, key_scope: TransparentKeyScope, gap_limit: u32, ) -> Result<Option<NonHardenedChildIndex>, Self::Error>

Returns the transparent address index at the start of the first gap of at least gap_limit indices in the given account, considering only addresses derived for the specified key scope.

fn store_address_range( &mut self, account_id: Self::AccountRef, key_scope: TransparentKeyScope, list: Vec<(Address, TransparentAddress, NonHardenedChildIndex)>, ) -> Result<(), Self::Error>

Persists a range of derived transparent addresses to the wallet storage.

impl<C: Borrow<Connection>, P: Parameters, CL, R> InputSource for WalletDb<C, P, CL, R>

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

Returns metadata for the spendable notes in the wallet.

type Error = SqliteClientError

The type of errors produced by a wallet backend.

type NoteRef = ReceivedNoteId

Backend-specific note identifier.

type AccountId = AccountUuid

Backend-specific account 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_spendable_notes_for_consolidation( &self, account: Self::AccountId, value: Zatoshis, source: ShieldedPool, target_height: TargetHeight, confirmations_policy: ConfirmationsPolicy, exclude: &[Self::NoteRef], lock_filter: LockFilter<'_>, max_additional_notes: usize, ) -> Result<ConsolidationNotes<Self::NoteRef>, Self::Error>

Returns notes for consolidation-aware selection from source.

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_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<'a, C: Borrow<Transaction<'a>>, P: Parameters, CL: Clock, R: RngCore> LowLevelWalletRead for WalletDb<C, P, CL, R>

type AccountId = AccountUuid

The type of the account identifier.

type AccountRef = AccountRef

A wallet-internal account identifier, used for efficient lookups within the data store.

type Account = Account

The type of account records returned by the wallet backend, providing access to the account’s viewing keys and capabilities.

type Error = SqliteClientError

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

type TxRef = TxRef

A wallet-internal transaction identifier.

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

Returns the height to which the wallet has been fully scanned: the greatest height for which the wallet has trial-decrypted this and all preceding blocks above the wallet’s birthday height, or Ok(None) if no such height exists.

fn select_receiving_address( &self, account: Self::AccountId, receiver: &Receiver, ) -> Result<Option<ZcashAddress>, Self::Error>

Returns the most likely wallet address that corresponds to the protocol-level receiver of a note or UTXO.

fn find_involved_accounts( &self, tx_refs: impl IntoIterator<Item = Self::TxRef>, ) -> Result<HashSet<(Self::AccountId, Option<TransparentKeyScope>)>, Self::Error>

Available on crate feature transparent-inputs only.

Finds the set of accounts that either provide inputs to or receive outputs from any of the provided transactions.

fn find_account_for_transparent_address( &self, address: &TransparentAddress, ) -> Result<Option<(Self::AccountId, Option<TransparentKeyScope>)>, Self::Error>

Available on crate feature transparent-inputs only.

Detects and returns the identifier for the account to which the address belongs, if any.

fn detect_accounts_transparent<'t>( &self, spends: impl Iterator<Item = &'t OutPoint>, ) -> Result<HashSet<Self::AccountId>, Self::Error>

Available on crate feature transparent-inputs only.

Detects the set of accounts that received transparent outputs corresponding to the provided OutPoints. This is used to determine which account(s) funded a given transaction.

fn detect_accounts_sapling<'t>( &self, spends: impl Iterator<Item = &'t Nullifier>, ) -> Result<HashSet<Self::AccountId>, Self::Error>

Detects the set of accounts that received Sapling outputs that, when spent, reveal(ed) the given Nullifiers. This is used to determine which account(s) funded a given transaction.

fn get_wallet_transparent_output( &self, outpoint: &OutPoint, target_height: Option<TargetHeight>, ) -> Result<Option<WalletTransparentOutput<Self::AccountId>>, Self::Error>

Available on crate feature transparent-inputs only.

Get information about a transparent output controlled by the wallet.

fn get_txs_spending_transparent_outputs_of( &self, tx_ref: Self::TxRef, ) -> Result<Vec<(Self::TxRef, Transaction)>, Self::Error>

Returns the vector of transactions in the wallet that spend the transparent outputs of the referenced transaction, but for which the amount of fee paid is unknown. This should include conflicted transactions and transactions that have expired without having been mined.

fn detect_sapling_spend( &self, nf: &Nullifier, ) -> Result<Option<Self::TxRef>, Self::Error>

Finds the reference to the transaction that reveals the given Sapling nullifier in the backing data store, if known.

fn get_account_ref( &self, account_uuid: Self::AccountId, ) -> Result<Self::AccountRef, Self::Error>

Available on crate feature transparent-inputs only.

Returns the wallet-internal account reference for the given external account identifier.

fn get_account_internal( &self, account_id: Self::AccountRef, ) -> Result<Option<Account>, SqliteClientError>

Available on crate feature transparent-inputs only.

Returns the full account record for the given wallet-internal account reference.

fn get_funding_accounts<T>( &self, tx: &T, ) -> Result<HashSet<Self::AccountId>, Self::Error>

where T: TxMeta,

Returns the set of account identifiers for accounts that spent notes and/or UTXOs in the construction of the given transaction.

impl<'a, C: Borrow<Transaction<'a>>, P: Parameters, CL: Clock, R: RngCore> LowLevelWalletWrite for WalletDb<C, P, CL, R>

fn put_block_meta( &mut self, block_height: BlockHeight, block_hash: BlockHash, block_time: u32, sapling_commitment_tree_size: u32, sapling_output_count: u32, ) -> Result<(), Self::Error>

Add metadata about a block to the wallet data store.

fn put_tx_meta( &mut self, tx: &WalletTx<Self::AccountId>, height: BlockHeight, ) -> Result<Self::TxRef, Self::Error>

Add metadata about a transaction to the wallet data store.

fn put_tx_data( &mut self, tx: &Transaction, fee: Option<Zatoshis>, created_at: Option<OffsetDateTime>, target_height: Option<TargetHeight>, observed_height: BlockHeight, ) -> Result<Self::TxRef, Self::Error>

Adds the given transaction to the wallet.

fn set_transaction_status( &mut self, txid: TxId, status: TransactionStatus, ) -> Result<(), Self::Error>

Updates transaction metadata to reflect that the given transaction status has been observed.

fn put_zip318_classification( &mut self, tx_ref: Self::TxRef, classification: Zip318Classification, ) -> Result<(), Self::Error>

Records how a transaction classifies against ZIP 318, so that a wallet can label a migration transaction in its history without consulting a migration plan.

fn put_received_sapling_note<T: ReceivedSaplingOutput<AccountId = Self::AccountId>>( &mut self, output: &T, tx_ref: Self::TxRef, target_or_mined_height: Option<BlockHeight>, spent_in: Option<Self::TxRef>, ) -> Result<(), Self::Error>

Adds information about a received Sapling note to the wallet, or updates any existing record for that output.

fn mark_sapling_note_spent( &mut self, nf: &Nullifier, tx_ref: Self::TxRef, ) -> Result<bool, Self::Error>

Updates the backing store to indicate that the Sapling output having the given nullifier is spent in the transaction referenced by spent_in_tx. This may result in multiple distinct transactions being recorded as having spent the note; only one of these transactions will end up having been mined (by consensus). If an attempt is made to associate a nullifier with a mined transaction, and another mined transaction reveals the same nullifier, implementations of this method must return an error.

fn track_block_sapling_nullifiers( &mut self, block_height: BlockHeight, nfs: &[(TxIndex, TxId, Vec<Nullifier>)], ) -> Result<(), Self::Error>

Causes the given Sapling output nullifiers to be tracked by the wallet.

fn prune_tracked_nullifiers( &mut self, pruning_depth: u32, ) -> Result<(), Self::Error>

Removes tracked nullifiers that are no longer needed for spend detection.

fn put_sent_output( &mut self, from_account_uuid: Self::AccountId, tx_ref: Self::TxRef, output_index: usize, recipient: &Recipient<Self::AccountId>, value: Zatoshis, memo: Option<&MemoBytes>, ) -> Result<(), Self::Error>

Records information about a transaction output that your wallet created, from the constituent properties of that output.

fn update_tx_fee( &mut self, tx_ref: Self::TxRef, fee: Zatoshis, ) -> Result<(), Self::Error>

Updates the wallet’s view of a transaction to indicate the miner’s fee paid by the transaction.

fn put_transparent_output( &mut self, output: &WalletTransparentOutput<Self::AccountId>, observation_height: BlockHeight, known_unspent: bool, ) -> Result<(Self::AccountId, Option<TransparentKeyScope>), Self::Error>

Available on crate feature transparent-inputs only.

Adds a transparent output observed by the wallet to the data store, or updates any existing record for that output.

fn mark_transparent_utxo_spent( &mut self, outpoint: &OutPoint, spent_in_tx: Self::TxRef, ) -> Result<bool, Self::Error>

Available on crate feature transparent-inputs only.

Updates the backing store to indicate that the UTXO referred to by outpoint is spent in the transaction referenced by spent_in_tx.

fn generate_transparent_gap_addresses( &mut self, account_id: Self::AccountId, key_scope: TransparentKeyScope, request: UnifiedAddressRequest, ) -> Result<(), Self::Error>

Available on crate feature transparent-inputs only.

Updates the wallet backend by generating and caching addresses for the given key scope such that at least the backend’s configured gap limit worth of addresses exist at indices successive from that of the last address that received a mined transaction.

fn queue_transparent_spend_detection( &mut self, receiving_address: TransparentAddress, tx_ref: Self::TxRef, output_index: u32, ) -> Result<(), Self::Error>

Available on crate feature transparent-inputs only.

Adds a TransactionDataRequest::TransactionsInvolvingAddress request to the transaction data request queue. When the transparent output of tx_ref at output index output_index (which must have been received at receiving_address) is detected as having been spent, this request will be considered fulfilled.

fn queue_transparent_input_retrieval( &mut self, tx_ref: Self::TxRef, d_tx: &DecryptedTransaction<'_, Transaction, Self::AccountId>, ) -> Result<(), Self::Error>

Available on crate feature transparent-inputs only.

Adds TransactionDataRequest::Enhancement requests for transactions that generated the transparent inputs to the provided DecryptedTransaction to the transaction data request queue.

fn queue_tx_retrieval( &mut self, txids: impl Iterator<Item = TxId>, dependent_tx_ref: Option<Self::TxRef>, ) -> Result<(), Self::Error>

Adds a TransactionDataRequest::Enhancement request for the enhancement of the given transaction to the transaction data request queue. The dependent_tx_ref parameter specifies the transaction that caused this request to be generated, likely as part of the process of traversing the transparent transaction graph by inspecting the inputs of a transaction with outputs that were received by the wallet.

fn queue_tx_status(&mut self, txid: TxId) -> Result<(), Self::Error>

Adds a TransactionDataRequest::GetStatus request for a transaction whose mined status cannot be learned through ordinary compact-block scanning.

fn delete_retrieval_queue_entries( &mut self, txid: TxId, ) -> Result<(), Self::Error>

Deletes the TransactionDataRequest::Enhancement request for the given transaction ID from the transaction data request queue, without removing any durable status-observation intent for the transaction.

fn notify_scan_complete( &mut self, range: Range<BlockHeight>, wallet_note_positions: &[(ShieldedPool, Position)], ) -> Result<(), Self::Error>

Updates the state of the wallet backend to indicate that the given range of blocks has been fully scanned, identifying the position in the note commitment tree of any notes belonging to the wallet that were discovered in the process of scanning.

fn update_gap_limits( &mut self, gap_limits: &GapLimits, txid: TxId, observation_height: BlockHeight, ) -> Result<(), Self::Error>

Available on crate feature transparent-inputs only.

impl<C, P, CL, R> OutputLockStore for WalletDb<C, P, CL, R>

where C: BorrowMut<Connection>, P: Parameters, CL: Clock, R: RngCore,

type Error = SqliteClientError

The type of errors produced by the lock store.

type AccountId = AccountUuid

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<P, CL, R> OutputLockStore for WalletDb<SqlTransaction<'_>, P, CL, R>

where P: Parameters, CL: Clock, R: RngCore,

This impl block is only usable when you already have an SqlTransaction, meaning you are inside a WalletDb::transactionally block with a lock on the database.

type Error = SqliteClientError

The type of errors produced by the lock store.

type AccountId = AccountUuid

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<C: BorrowMut<Connection>, P: Parameters, CL, R> WalletCommitmentTrees for WalletDb<C, P, CL, R>

type Error = Error

type SaplingShardStore<'a> = SqliteShardStore<&'a Transaction<'a>, Node, SAPLING_SHARD_HEIGHT>

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<SqliteShardStore<&'a Transaction<'a>, Node, SAPLING_SHARD_HEIGHT>, { 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: &[LocatedTree<Option<Arc<Node>>, (Node, RetentionFlags)>], cap: Option<&Tree<Option<Arc<Node>>, (Node, RetentionFlags)>>, 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<P: Parameters, CL, R> WalletCommitmentTrees for WalletDb<SqlTransaction<'_>, P, CL, R>

type Error = Error

type SaplingShardStore<'a> = SqliteShardStore<&'a Transaction<'a>, Node, SAPLING_SHARD_HEIGHT>

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<SqliteShardStore<&'a Transaction<'a>, Node, SAPLING_SHARD_HEIGHT>, { sapling::NOTE_COMMITMENT_TREE_DEPTH }, SAPLING_SHARD_HEIGHT>) -> Result<A, E>, E: From<ShardTreeError<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: &[LocatedTree<Option<Arc<Node>>, (Node, RetentionFlags)>], cap: Option<&Tree<Option<Arc<Node>>, (Node, RetentionFlags)>>, 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<C: Borrow<Connection>, P: Parameters, CL, R> WalletRead for WalletDb<C, P, CL, R>

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

Implements this method with a single SQL query, avoiding the O(accounts × addresses) scan that delegating to zcash_client_backend::data_api::defaults::find_account_for_address would require. See zcash_client_backend::data_api::WalletRead::find_account_for_address for the semantics.

type Error = SqliteClientError

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

type AccountId = AccountUuid

The type of the account identifier.

type Account = 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 get_last_generated_address_matching( &self, account: Self::AccountId, request: 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 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.

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.

impl<C: Borrow<Connection>, P: Parameters, CL, R> WalletTest for WalletDb<C, P, CL, R>

Available on crate features test-dependencies only.

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, target_height: Option<TargetHeight>, ) -> Result<Option<WalletTransparentOutput<<Self as InputSource>::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<C: BorrowMut<Connection>, P: Parameters, CL: Clock, R: RngCore> WalletWrite for WalletDb<C, P, CL, R>

type UtxoRef = UtxoId

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, ufvk: &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_uuid: <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_uuid: <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, d_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.

impl<P: Parameters, CL: Clock, R: RngCore> WalletWrite for WalletDb<SqlTransaction<'_>, P, CL, R>

type UtxoRef = UtxoId

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, ufvk: &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_uuid: <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_uuid: <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, d_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.