Enum Solution

pub enum Solution {
    Common([u8; 1344]),
    Regtest([u8; 36]),
}

Equihash Solution in compressed format.

A wrapper around [u8; n] where n is the solution size because Rust doesn’t implement common traits like Debug, Clone, etc. for collections like arrays beyond lengths 0 to 32.

The size of an Equihash solution in bytes is always 1344 on Mainnet and Testnet, and is always 36 on Regtest so the length of this type is fixed.

Variants

Common([u8; 1344])

Equihash solution on Mainnet or Testnet

Regtest([u8; 36])

Equihash solution on Regtest

Implementations

impl Solution

pub const INPUT_LENGTH: usize = 108usize

The length of the portion of the header used as input when verifying equihash solutions, in bytes.

Excludes the 32-byte nonce, which is passed as a separate argument to the verification function.

fn value(&self) -> &[u8]

Returns the inner value of the Solution as a byte slice.

pub fn check(&self, header: &Header) -> Result<(), Error>

Returns Ok(()) if EquihashSolution is valid for header

pub fn from_bytes(solution: &[u8]) -> Result<Self, SerializationError>

Returns a Solution containing the bytes from solution. Returns an error if solution is the wrong length.

pub fn for_proposal() -> Self

Returns a Solution of [0; SOLUTION_SIZE] to be used in block proposals.

pub fn solve<F>( header: Header, _cancel_fn: F, ) -> Result<AtLeastOne<Header>, SolverCancelled>

where F: FnMut() -> Result<(), SolverCancelled>,

Mines and returns one or more Solutions based on a template header. The returned header contains a valid nonce and solution.

If cancel_fn() returns an error, returns early with Err(SolverCancelled).

The nonce in the header template is taken as the starting nonce. If you are running multiple solvers at the same time, start them with different nonces. The solution in the header template is ignored.

This method is CPU and memory-intensive. It uses 144 MB of RAM and one CPU core while running. It can run for minutes or hours if the network difficulty is high.

Trait Implementations

impl Arbitrary for Solution

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<Solution>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Solution

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Solution

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

Formats the value using the given formatter.

impl Default for Solution

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Solution

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Solution

fn eq(&self, other: &Solution) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Solution

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToHex for &Solution

fn encode_hex<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

fn encode_hex_upper<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

impl ToHex for Solution

fn encode_hex<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

fn encode_hex_upper<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

impl ZcashDeserialize for Solution

fn zcash_deserialize<R: Read>(reader: R) -> Result<Self, SerializationError>

Try to read self from the given reader.

impl ZcashSerialize for Solution

fn zcash_serialize<W: Write>(&self, writer: W) -> Result<(), Error>

Write self to the given writer using the canonical format.

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

Helper function to construct a vec to serialize the current struct into

fn zcash_serialized_size(&self) -> usize

Get the size of self by using a fake writer.

impl Copy for Solution

impl Eq for Solution