Struct StarkTranscript 

pub struct StarkTranscript<EF, L>
where
    L: Lmcs,
    <L as Lmcs>::F: Field,
    EF: ExtensionField<<L as Lmcs>::F>,
{
    pub instance_shapes: InstanceShapes,
    pub instance_challenge: EF,
    pub main_commit: <L as Lmcs>::Commitment,
    pub randomness: Vec<EF>,
    pub aux_commit: <L as Lmcs>::Commitment,
    pub all_aux_values: Vec<Vec<EF>>,
    pub alpha: EF,
    pub beta: EF,
    pub quotient_commit: <L as Lmcs>::Commitment,
    pub z: EF,
    pub pcs_transcript: PcsTranscript<EF, L>,
}

Structured transcript view for the full lifted STARK protocol.

Captures instance shape metadata, commitments, sampled challenges, the OOD evaluation point, and the PCS sub-transcript. Constructed via from_proof, which mirrors steps 0–9 of verify_multi but skips the constraint check.

Fields

instance_shapes: InstanceShapes

Per-instance shape metadata. Validated and observed into the challenger by from_proof.

instance_challenge: EF

Throwaway challenge squeezed right after observing the instance shapes, used to clear the challenger’s absorb buffer so that later sampled challenges depend on the full shape metadata regardless of sponge state.

main_commit: <L as Lmcs>::Commitment

Main trace commitment.

randomness: Vec<EF>

Randomness sampled for auxiliary traces.

aux_commit: <L as Lmcs>::Commitment

Auxiliary trace commitment.

all_aux_values: Vec<Vec<EF>>

Aux values per AIR instance, observed into the transcript after the aux commitment.

alpha: EF

Constraint folding challenge alpha.

beta: EF

AIR accumulation challenge beta.

quotient_commit: <L as Lmcs>::Commitment

Quotient polynomial commitment.

z: EF

Out-of-domain evaluation point z.

pcs_transcript: PcsTranscript<EF, L>

PCS sub-transcript (DEEP evals, FRI rounds, query openings).

Implementations

impl<EF, L> StarkTranscript<EF, L>

where L: Lmcs, <L as Lmcs>::F: TwoAdicField, EF: ExtensionField<<L as Lmcs>::F>,

pub fn from_proof<A, SC>( config: &SC, instances: &[(&A, AirInstance<'_, <L as Lmcs>::F>)], proof: &StarkProof<<L as Lmcs>::F, EF, SC>, challenger: <SC as StarkConfig<<L as Lmcs>::F, EF>>::Challenger, ) -> Result<(StarkTranscript<EF, L>, <<SC as StarkConfig<<L as Lmcs>::F, EF>>::Challenger as CanFinalizeDigest>::Digest), VerifierError>

where A: LiftedAir<<L as Lmcs>::F, EF>, SC: StarkConfig<<L as Lmcs>::F, EF, Lmcs = L>,

Parse a STARK transcript from proof data and a challenger.

Mirrors steps 0–9 of verify_multi: 0. Validate instance shapes, then observe log trace heights into the challenger and squeeze a throwaway instance_challenge to clear the absorb buffer

1. Receive main trace commitment
2. Sample randomness for auxiliary traces
3. Receive auxiliary trace commitment
4. Receive aux values (per AIR instance)
5. Sample constraint folding alpha and accumulation beta
6. Receive quotient commitment
7. Sample OOD point z
8. Build commitment widths for PCS
9. Parse PCS sub-transcript via PcsTranscript::from_verifier_channel

Does not verify constraints or check the quotient identity. Finalizes the transcript and returns the digest alongside the parsed view.