Struct snarkvm_ledger_coinbase::CoinbaseSolution

pub struct CoinbaseSolution<N: Network> { /* private fields */ }

The coinbase puzzle solution is composed of individual prover solutions.

Implementations

impl<N: Network> CoinbaseSolution<N>

pub fn new(solutions: Vec<ProverSolution<N>>) -> Result<Self>

Initializes a new instance of the solutions.

pub fn puzzle_commitments( &self ) -> impl '_ + Iterator<Item = &PuzzleCommitment<N>>

Returns the puzzle commitments.

pub fn len(&self) -> usize

Returns the number of solutions.

pub fn is_empty(&self) -> bool

Returns true if there are no solutions.

pub fn get_solution( &self, puzzle_commitment: &PuzzleCommitment<N> ) -> Option<&ProverSolution<N>>

Returns the prover solution for the puzzle commitment.

pub fn to_combined_proof_target(&self) -> Result<u128>

Returns the combined sum of the prover solutions.

pub fn to_accumulator_point(&self) -> Result<Field<N>>

Returns the accumulator challenge point.

Methods from Deref<Target = IndexMap<PuzzleCommitment<N>, ProverSolution<N>>>

pub fn capacity(&self) -> usize

Return the number of elements the map can hold without reallocating.

This number is a lower bound; the map might be able to hold more, but is guaranteed to be able to hold at least this many.

Computes in O(1) time.

pub fn hasher(&self) -> &S

Return a reference to the map’s BuildHasher.

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

Computes in O(1) time.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Computes in O(1) time.

pub fn iter(&self) -> Iter<'_, K, V>

Return an iterator over the key-value pairs of the map, in their order

pub fn keys(&self) -> Keys<'_, K, V>

Return an iterator over the keys of the map, in their order

pub fn values(&self) -> Values<'_, K, V>

Return an iterator over the values of the map, in their order

pub fn contains_key<Q>(&self, key: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

Return true if an equivalent to key exists in the map.

Computes in O(1) time (average).

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where Q: Hash + Equivalent<K> + ?Sized,

Return a reference to the value stored for key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return references to the key-value pair stored for key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return item index, key and value

pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>

where Q: Hash + Equivalent<K> + ?Sized,

Return item index, if it exists in the map

Computes in O(1) time (average).

pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>

where K: Ord,

Search over a sorted map for a key.

Returns the position where that key is present, or the position where it can be inserted to maintain the sort. See slice::binary_search for more details.

Computes in O(log(n)) time, which is notably less scalable than looking the key up using get_index_of, but this can also position missing keys.

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> Ordering,

Search over a sorted map with a comparator function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by for more details.

Computes in O(log(n)) time.

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F ) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> B, B: Ord,

Search over a sorted map with an extraction function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by_key for more details.

Computes in O(log(n)) time.

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&K, &V) -> bool,

Returns the index of the partition point of a sorted map according to the given predicate (the index of the first element of the second partition).

See slice::partition_point for more details.

Computes in O(log(n)) time.

pub fn as_slice(&self) -> &Slice<K, V>

Returns a slice of all the key-value pairs in the map.

Computes in O(1) time.

pub fn get_index(&self, index: usize) -> Option<(&K, &V)>

Get a key-value pair by index

Valid indices are 0 <= index < self.len()

Computes in O(1) time.

pub fn get_range<R>(&self, range: R) -> Option<&Slice<K, V>>

where R: RangeBounds<usize>,

Returns a slice of key-value pairs in the given range of indices.

Valid indices are 0 <= index < self.len()

Computes in O(1) time.

pub fn first(&self) -> Option<(&K, &V)>

Get the first key-value pair

Computes in O(1) time.

pub fn last(&self) -> Option<(&K, &V)>

Get the last key-value pair

Computes in O(1) time.

pub fn par_keys(&self) -> ParKeys<'_, K, V>

Return a parallel iterator over the keys of the map.

While parallel iterators can process items in any order, their relative order in the map is still preserved for operations like reduce and collect.

pub fn par_values(&self) -> ParValues<'_, K, V>

Return a parallel iterator over the values of the map.

While parallel iterators can process items in any order, their relative order in the map is still preserved for operations like reduce and collect.

pub fn par_eq<V2, S2>(&self, other: &IndexMap<K, V2, S2>) -> bool

where V: PartialEq<V2>, V2: Sync, S2: BuildHasher + Sync,

Returns true if self contains all of the same key-value pairs as other, regardless of each map’s indexed order, determined in parallel.

Trait Implementations

impl<N: Clone + Network> Clone for CoinbaseSolution<N>

fn clone(&self) -> CoinbaseSolution<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Network> Debug for CoinbaseSolution<N>

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

Prints the solutions as a JSON-string.

impl<N: Network> Deref for CoinbaseSolution<N>

type Target = IndexMap<PuzzleCommitment<N>, ProverSolution<N>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, N: Network> Deserialize<'de> for CoinbaseSolution<N>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the solutions from a JSON-string or buffer.

impl<N: Network> Display for CoinbaseSolution<N>

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

Displays the solutions as a JSON-string.

impl<N: Network> FromBytes for CoinbaseSolution<N>

fn read_le<R: Read>(reader: R) -> IoResult<Self>

Reads the solutions from the buffer.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Returns Self from a byte array in little-endian order.

impl<N: Network> FromStr for CoinbaseSolution<N>

fn from_str(solutions: &str) -> Result<Self, Self::Err>

Initializes the solutions from a JSON-string.

type Err = Error

The associated error which can be returned from parsing.

impl<N: PartialEq + Network> PartialEq for CoinbaseSolution<N>

fn eq(&self, other: &CoinbaseSolution<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Network> Serialize for CoinbaseSolution<N>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serializes the solutions to a JSON-string or buffer.

impl<N: Network> ToBytes for CoinbaseSolution<N>

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes the solutions to the buffer.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

Returns self as a byte array in little-endian order.

impl<N: Eq + Network> Eq for CoinbaseSolution<N>

impl<N: Network> StructuralPartialEq for CoinbaseSolution<N>