Struct DeviceSpongeState 

#[repr(C)]
pub struct DeviceSpongeState {
    pub state: [F; 16],
    pub absorb_idx: u32,
    pub sample_idx: u32,
}

Device-side sponge state, matching the CUDA DeviceSpongeState struct.

This struct is #[repr(C)] to ensure ABI compatibility with the CUDA kernel. The state layout matches the Poseidon2 duplex sponge with overwrite mode.

This struct implements the same logic as DuplexSponge from openvm_stark_backend, but with public fields so we can sync state to/from GPU.

Fields

state: [F; 16]

Full Poseidon2 state (WIDTH = 16 elements)

absorb_idx: u32

Current absorb position (0 <= absorb_idx < CHUNK)

sample_idx: u32

Current sample position (0 <= sample_idx <= CHUNK)

Implementations

impl DeviceSpongeState

pub fn observe(&mut self, value: F)

Observe a value into the sponge (absorb phase).

This matches the behavior of DuplexSponge::observe.

pub fn sample(&mut self) -> F

Sample a value from the sponge (squeeze phase).

This matches the behavior of DuplexSponge::sample.

Trait Implementations

impl Clone for DeviceSpongeState

fn clone(&self) -> DeviceSpongeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceSpongeState

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

Formats the value using the given formatter.

impl Default for DeviceSpongeState

fn default() -> Self

Returns the “default value” for a type.

impl FiatShamirTranscript<BabyBearPoseidon2Config> for DeviceSpongeState

fn observe(&mut self, value: F)

fn sample(&mut self) -> F

fn observe_commit(&mut self, digest: Digest)

Implementations should pass through to Self::observe, but no default implementation is provided since an explicit conversion from Digest to array of F is required.

fn observe_ext(&mut self, value: <SC as StarkProtocolConfig>::EF)

fn sample_ext(&mut self) -> <SC as StarkProtocolConfig>::EF

fn sample_bits(&mut self, bits: usize) -> u64

Samples and returns an integer in the range [0, 2^bits).

fn check_witness( &mut self, bits: usize, witness: <SC as StarkProtocolConfig>::F, ) -> bool

Checks a proof-of-work witness: observes witness into the transcript and accepts iff the next Self::sample_bits is zero (probability ≈ 2^{-bits} for a random witness, so Self::grind tries ≈ 2^bits witnesses to find one).

fn grind(&mut self, bits: usize) -> <SC as StarkProtocolConfig>::F

Finds a proof-of-work witness w such that Self::check_witness(bits, w) holds, by brute force over the base field.