Struct Solution

pub struct Solution {
    nonce: Nonce,
    effort: Effort,
    seed_head: SeedHead,
    proof: Solution,
}

One potential solution to some puzzle Instance

The existence of a Solution guarantees that the solution is well formed (for example, the correct length, the correct order in the Equi-X solution) but it makes no guarantee to actually solve any specific puzzle instance.

Fields

nonce: Nonce

Arbitrary value chosen by the solver to reach a valid solution

Services are responsible for remembering used values to prevent replay.

effort: Effort

The effort chosen by the client

This is validated against the actual effort spent by the client using a combination of two checks:

• We can ensure the effort value here was chosen prior to successfully solving the Equi-X puzzle just by verifying the Equi-X proof. Effort values are part of the crate::pow::v1::challenge::Challenge string the puzzle is constructed around.

• We can ensure, on average, that the proper proportion of Equi-X solutions have been discarded. The proof and challenge are hashed, and the resulting digest is effectively a random variable that must fit within a range inversely proportional to the effort. This test happens in crate::pow::v1::challenge::Challenge::check_effort.

seed_head: SeedHead

Prefix of the Seed used in this puzzle Instance

A service will normally have two active Seed values at once. This prefix is sufficient to distinguish between them. (Services skip seeds which would have the same prefix as the last seed.)

proof: Solution

Equi-X solution which claims to prove the above effort choice

Implementations

impl Solution

pub fn new( nonce: Nonce, effort: Effort, seed_head: SeedHead, proof: Solution, ) -> Self

Construct a new Solution around a well-formed [equix::Solution] proof.

pub fn try_from_bytes( nonce: Nonce, effort: Effort, seed_head: SeedHead, bytes: &SolutionByteArray, ) -> Result<Self, SolutionErrorV1>

Try to build a Solution from an unvalidated equix::SolutionByteArray.

This will either return a Solution or a SolutionErrorV1::Order.

pub fn nonce(&self) -> &Nonce

Get the winning Nonce value used in this solution

pub fn effort(&self) -> Effort

Get the client-chosen and provable Effort value used in this solution

pub fn seed_head(&self) -> SeedHead

Get the SeedHead value identifying the puzzle this solution is for

pub fn proof(&self) -> &Solution

Reference the [equix::Solution] backing the proof portion

pub fn proof_to_bytes(&self) -> SolutionByteArray

Clone the proof portion of the solution in its canonical byte string format

Trait Implementations

impl Clone for Solution

fn clone(&self) -> Solution

Returns a duplicate 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 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 Eq for Solution

impl StructuralPartialEq for Solution