Struct CertificateSigner 

pub struct CertificateSigner { /* private fields */ }

Direct RHDL composition of one DSig packer and exactly one cached signer.

The sole stateful child is the Ed25519 project’s scalable RHDL core, Ed25519SignCoreSmall = Ed25519SignCore<1, 1, 1, 0> (vendored in vendor/ed25519-scalable-core; one fixed-base machine, one SHA-512 ring, one scalar ring, 128 contexts). It accepts up to 32 requests in flight and may finish them out of order. This wrapper adds no FIFO, register, controller, admission policy, credit state, fault latch, or output backpressure. Its output is CachedSignOut itself.

The caller must reserve every completion slot in advance, latch any internal_error before processing a coincident valid pulse, bind the returned tag to the full namespace/root/signer identity, and drain before clearing. Quarantine outstanding requests across reset; neither reset nor clear proves cancellation or grants permission to reuse a DSig allocation. No bank may be marked certified solely because this wrapper emitted bytes.

Trait Implementations

impl Clone for CertificateSigner

fn clone(&self) -> CertificateSigner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CertificateSigner

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

Formats the value using the given formatter.

impl Default for CertificateSigner

fn default() -> CertificateSigner

Returns the “default value” for a type.

impl Synchronous for CertificateSigner

type S = (<CertificateSigner as SynchronousDQ>::Q, <Ed25519SignCore<1, 1, 1, 0> as Synchronous>::S)

The simulation state type. This type is used to represent the internal state of the circuit during simulation. It must be PartialEq and Clone. It holds whatever state is needed to compute the output of the circuit given it’s input. This state is typically auto-derived by the Synchronous derive macro, and it’s typically a struct containing the states of all the subcircuits, along with their last know outputs.

fn init(&self) -> Self::S

Initialize the simulation state. This method returns the initial state of the circuit for simulation. This is typically auto-derived by the Synchronous derive macro, and it typically initializes the states of all the subcircuits to their initial states.

fn children( &self, parent_scope: &ScopedName, ) -> impl Iterator<Item = Result<Descriptor<SyncKind>, RHDLError>>

Iterate over the child circuits of this circuit.

fn sim( &self, clock_reset: ClockReset, input: <Self as SynchronousIO>::I, state: &mut Self::S, ) -> <Self as SynchronousIO>::O

Simulate the circuit given it’s input, clock reset, and current state.

fn descriptor( &self, scoped_name: ScopedName, ) -> Result<Descriptor<SyncKind>, RHDLError>

Provides run time reflection of the circuit.

impl SynchronousDQ for CertificateSigner

type Q = CertificateSignerQ

The type of the internal data output from the children of the circuit.

type D = CertificateSignerD

The type of the internal data input to the children of the circuit.

impl SynchronousIO for CertificateSigner

type I = CertificateSignerInput

Input: key control plus one certificate request.

type O = CachedSignOut

Output: the core’s own output, unchanged.

type Kernel = certificate_signer_kernel

The wiring kernel that runs every clock.