Struct SignerControl 

pub struct SignerControl {

    pub done: b32,
    pub consumed: b32,
    pub meta_ok: bool,
    pub hashing: bool,
    pub tail_pending: bool,
    pub in_tail: bool,
    pub tail_block: [b32; 16],
    pub tail_cv: [b32; 8],
    pub certs: b2,
    pub queue: [Work; 2],
    pub prep_step: b4,
    pub prep: Work,
    pub ready: Work,
    pub stream: Work,
    pub chain: b7,
    pub reads: [NodeRead; 5],
    pub packed: b5,
    pub pack_frame: b2,
    pub pack_index: b64,
    pub frames_used: b3,
    pub next_frame: b2,
    pub complete: b3,
    pub drain_frame: b2,
    pub drain_beat: b5,
    pub drain_pending: bool,
    pub drain_last: bool,
    pub beat_valid: bool,
    pub drain_read: b7,
    pub frames_out: b32,
}

Resettable control.

Fields

done: b32

Keys finished by the factory.

consumed: b32

Keys burned.

meta_ok: bool

The metadata RAM output holds key consumed.

hashing: bool

A message hash is in flight.

tail_pending: bool

Profile 2: the first digest block returned; the tail is to be offered.

in_tail: bool

Profile 2: the tail block is in flight (its result is the digest).

tail_block: [b32; 16]

Profile 2: the tail block (message bytes 16..64, zero-padded).

tail_cv: [b32; 8]

Profile 2: the first block’s chaining value.

certs: b2

Certificates held (0..=2).

queue: [Work; 2]

Burned keys awaiting digits/preparation, oldest first.

prep_step: b4

Preparation step: 0 idle, 1..=4 sibling reads, 5..=10 header writes.

The counts are for the 8-slice build: steps 1..=SUBTREE_LEVELS read siblings, then HEADER_BEATS steps write the header.

prep: Work

The work item being prepared.

ready: Work

Prepared, waiting to stream.

stream: Work

The work item being streamed.

chain: b7

Next chain to address while streaming (68 = finished addressing).

reads: [NodeRead; 5]

Cache reads in flight, newest at index 0. A read issued this cycle reaches the end of this line exactly when its node leaves the cache (CACHE_READ_LATENCY cycles), so the token travels with its data.

packed: b5

Packer beats written for the frame being packed.

pack_frame: b2

Frame slot the packer writes into.

pack_index: b64

Message index of the frame being packed.

frames_used: b3

Frame slots in use (preparing, streaming, complete or draining).

next_frame: b2

Next frame slot to allocate.

complete: b3

Completed frames not yet drained.

drain_frame: b2

Frame slot being drained.

drain_beat: b5

Next beat to drain.

drain_pending: bool

A drain read is outstanding.

drain_last: bool

The outstanding drain read is the frame’s last beat.

beat_valid: bool

The output register holds an undelivered beat.

drain_read: b7

Frame-buffer address of the outstanding drain read (held while stalled).

frames_out: b32

Frames fully drained.

Trait Implementations

impl Clone for SignerControl

fn clone(&self) -> SignerControl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignerControl

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

Formats the value using the given formatter.

impl Digital for SignerControl

const BITS: usize

Associated constant that gives the total number of bits needed to represent the value.

fn static_kind() -> Kind

Returns the [Kind] (run time type descriptor) of the value as a static method

fn bin(self) -> Box<[BitX]>

Returns the binary representation of the value as a vector of [BitX].

fn dont_care() -> Self

Returns a “don’t care” value for the type.

fn bits() -> usize

Returns the number of bits needed to represent the value.

fn kind(&self) -> Kind

Returns the [Kind] (run time type descriptor) of the value.

fn typed_bits(self) -> TypedBits

Returns the value as a [TypedBits], which includes both the bits and the kind.

fn discriminant(self) -> TypedBits

Returns the discriminant of the value as a [TypedBits].

fn variant_kind(self) -> Kind

Returns the [Kind] of the variant if the value is an enum with variants.

fn binary_string(self) -> String

Returns the binary representation of the value as a string of ‘0’, ‘1’, and ‘X’.

impl PartialEq for SignerControl

fn eq(&self, other: &SignerControl) -> 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 Copy for SignerControl

impl StructuralPartialEq for SignerControl