convert into a JobResult. panics if job did not finish.

Map the inner block (if any) to some result

IMPORTANT: the returned iterator is NOT async. The database is queried synchrously so the caller will block. Consider using `spawn_blocking()` task

generates a random JobId

Acquire read lock and return an `RwLockReadGuard` # Examples ``` # use neptune_cash::application::locks::std::{AtomicRw, traits::*}; struct Car { yea

Acquire write lock and return an `RwLockWriteGuard` # Examples ``` # use neptune_cash::application::locks::std::{AtomicRw, traits::*}; struct Car { y

store a block (non coinbase)

Return the number of transactions currently stored in the Mempool. Computes in O(1)

documented in trait. do not add doc-comment.

get transaction from mempool Computes in O(1) from HashMap

Get a global state object for unit test purposes. This global state is populated with state from the genesis block, e.g. in the archival mutator set a

returns the address that corresponds to this spending key.

Send a message to the miner task (if any). Do no use the `async` `send` function because it blocks until there is spare capacity on the channel. Mess

authenticate this token against known valid token data. `valid_tokens` should be an array containing one valid token of each [Token] variant. valida

Build a fake block with a random hash, containing *two* outputs for the composer. Returns (block, composer-utxos).

access the public Api type in immutable context

Map the inner block (if any) to None if the predicate does not hold

Insert a transaction into the mempool. It is the caller's responsibility to validate the transaction. The caller must also ensure that the transactio

Immutably access the data of type `T` in a closure and possibly return a result of type `R` # Examples ``` # use neptune_cash::application::locks::st

Append an element to the archival MMR, return the membership proof of the newly added leaf.

Update all of archival state with a new block which is set as tip. May also be used to set the tip back to any earlier block, including the genesis b

Return the mutator set as it looks after the application of this block. Includes the guesser-fee UTXOs which are not included by the `mutator_set_acc

Return the wallet status relative to the current tip.

Return the number of leaves in the tree

Generates an addition record from an item and explicit random- ness. The addition record is itself a commitment to the item.

generate the proof. if the network uses mock proofs (eg Network::RegTest), this will return immediately with a mock [Proof]. otherwise it will initi

access the public Api in mutable context

returns present blockchain tip info.

Determine whether the ith bit is set. # Panics - If the limb index corresponding to the given bit index is smaller than usize::MAX.

Return a setup with empty databases, and with the genesis block set as tip. Returns: (peer_broadcast_channel, from_main_receiver, to_main_transmitter

Punish a peer for bad behavior. Return `Err` if the peer in question is (now) banned. # Locking: acquires `global_state_lock` for write

Derive a pseudorandom [`PeerId`] from a [`SocketAddr`]. This is a controversial feature, with accordingly complex motivation -- bear with: This map

# Panics - if the index is not less than window size

Subtract a number from a block height. NOT* implemented as trait `CheckedSub` because of type mismatch.

perform move+modify operation. The input [TransactionKernel] is replaced with a copy that contains any modifications previously set in the builder.

Used in tests, but also in genesis_node.rs, which explains why this function and the module in which it is lived is marked `pub`.

retrieve a crate-internal transaction initiator for calling "traditional" create_transaction()

derives a generation spending key at `index` note: this is a read-only method and does not modify wallet state. When requesting a new key for purpos

Configure the proving capacity.

If any output UTXO(s) are going back to our wallet (eg change utxo) we add them to pool of expected incoming UTXOs so that we can synchronize them aft

get monitored_utxos.

Build the list of transaction inputs, taking `number`-many inputs after after filtering out policy-incompliant UTXOs and after sorting by priority.

Write the WriteBatch to database atomically The sync flag forces filesystem sync operation eg fsync which will be slower than async writes, which are

adds Tx to mempool and notifies wallet of change. value represents the value that the transaction has to caller.

Return the digests of the peaks of the MMR

remove a transaction from the `Mempool` Does nothing if the transaction cannot be found in the mempool.

Verify a Merkle tree membership claim using the nondeterministically supplied digests as authentication path. Crashes the VM if verification fails.

Get the amount of native currency that are encapsulated in this UTXO, regardless of which other coins are present. (Even if that makes the native curr

retrieve a transaction recipient in immutable context.

check if transaction exists in mempool Computes in O(1) from HashMap