Struct ScannerChip 

pub struct ScannerChip<F>
where
    F: CircuitField,
{ /* private fields */ }

Chip for scanning: automaton parsing and substring verification.

Implementations

impl<F> ScannerChip<F>

where F: CircuitField + Ord,

pub fn parse( &self, layouter: &mut impl Layouter<F>, parser: AutomatonParser, input: &[AssignedByte<F>], ) -> Result<Vec<AssignedNative<F>>, Error>

Parses input in-circuit w.r.t. a regular expression / transducer and outputs the sequence of integers it produces. The parser may either be part of a static library (faster to parse) or an arbitrary regex (more costly but supports any regex). Both variants use the same fixed lookup table mechanism.

pub fn parse_varlen<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, parser: AutomatonParser, input: &ScannerVec<F, M, A>, ) -> Result<AssignedVector<F, AssignedNative<F>, M, A>, Error>

Parses the variable-length input in-circuit w.r.t. a regular expression / transducer and returns the sequence of markers it produces.

The returned vector has the same length as input’s buffer (M elements). It inherits the same get_limits, and padding_flags as input. Filler positions in the output are constrained to 0 (the self-loop transitions on initial/final states output marker 0).

impl<F> ScannerChip<F>

where F: CircuitField + Ord,

pub fn check_bytes( &self, layouter: &mut impl Layouter<F>, sequence: &[AssignedByte<F>], idx: &AssignedNative<F>, sub: &[AssignedByte<F>], ) -> Result<(), Error>

Asserts that sub is a contiguous subsequence of sequence starting at index idx (0-indexed). This function defers the actual circuit work: it records the call in the SequenceCache, grouping entries with the same sequence argument under a single tag. The circuit assignment happens later in Self::finalise_substring_checks.

Cost

The cost of one call is of the order of |sequence| + |sub| rows. Due to caching, multiple calls with the same sequence argument only pay the sequence-related cost once.

Range check

The starting index is range-checked (idx < 2^PARSING_MAX_LEN_BITS) so that the packed lookup value (idx + i) * (ALPHABET_MAX_SIZE + 1) + byte is injective over the field.

pub fn check_bytes_ext( &self, layouter: &mut impl Layouter<F>, sequence: &[AssignedNative<F>], idx: &AssignedNative<F>, sub: &[AssignedNative<F>], ) -> Result<(), Error>

More permissive version of Self::check_bytes that allows both sequence and sub to include the value 256. This function range-checks all of their cells by 257 to enable that.

Less resilient, and slightly less efficient than Self::check_bytes, but permits to encode more complex tests on bytes by using 256 as separator arbitrarily. E.g., the positions at which sub may start may be restricted by putting 256 blockers in sequence, and at the beginning and the end of sub.

pub fn assert_equal_fixlen( &self, layouter: &mut impl Layouter<F>, v1: &[AssignedByte<F>], v2: &[AssignedByte<F>], ) -> Result<(), Error>

Asserts that two byte slices of fixed length are element-wise equal. Proceeds by iterating and asserting equality over cells.

impl<F> ScannerChip<F>

where F: CircuitField + Ord,

pub fn check_bytes_varlen<const M_SEQ: usize, const A_SEQ: usize, const M_SUB: usize, const A_SUB: usize>( &self, layouter: &mut impl Layouter<F>, sequence: &ScannerVec<F, M_SEQ, A_SEQ>, idx: &AssignedNative<F>, sub: &ScannerVec<F, M_SUB, A_SUB>, ) -> Result<(), Error>

Similar to check_bytes, but supports variable-length inputs. If sub has known fixed length, use check_bytes_varlen_partial instead.

pub fn check_bytes_varlen_partial<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, sequence: &ScannerVec<F, M, A>, idx: &AssignedNative<F>, sub: &[AssignedByte<F>], ) -> Result<(), Error>

Similar to check_bytes, but the sequence is variable-length while sub is fixed-length. More efficient than check_bytes_varlen.

pub fn assert_equal_varlen<const M1: usize, const A1: usize, const M2: usize, const A2: usize>( &self, layouter: &mut impl Layouter<F>, v1: &ScannerVec<F, M1, A1>, v2: &ScannerVec<F, M2, A2>, ) -> Result<(), Error>

Asserts that two byte slices of variable length are element-wise equal. Proceeds by testing equality of the lengths, and checks that v2 is a substring of v1 at index 0. If either of the two vectors is also used as the sequence argument of another substring check, putting it as the v1 argument is the most cost efficient.

pub fn assert_equal_varlen_partial<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, v1: &ScannerVec<F, M, A>, v2: &[AssignedByte<F>], ) -> Result<(), Error>

Asserts that two byte slices of variable and fixed length, respectively, are element-wise equal. Proceeds by testing equality of the lengths, and checks equality of the varlen buffer with a padded slice.

impl<F> ScannerChip<F>

where F: CircuitField + Ord,

pub fn scanner_vec_to_byte_vector<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, sv: &ScannerVec<F, M, A>, ) -> Result<AssignedVector<F, AssignedByte<F>, M, A>, Error>

Converts a ScannerVec into an AssignedVector of AssignedBytes.

Filler positions (value 256) are replaced with 0 so that all buffer elements are valid bytes. The resulting vector can be passed to operations that expect AssignedByte inputs, such as variable-length SHA-256.

No range-check constraints are added: payload bytes were already range-checked during ScannerVec construction, and fillers are replaced by a known constant (0).

pub fn assign_scanner_vec<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, value: Value<Vec<u8>>, ) -> Result<ScannerVec<F, M, A>, Error>

Assigns a variable-length byte vector as a ScannerVec.

The input bytes are assigned as AssignedBytes (range-checked to [0, 255]), promoted to AssignedNative elements, and filler positions are constrained to ALPHABET_MAX_SIZE in-circuit.

pub fn scanner_vec_from_byte_vec<const M: usize, const A: usize>( &self, layouter: &mut impl Layouter<F>, vec: AssignedVector<F, AssignedByte<F>, M, A>, ) -> Result<ScannerVec<F, M, A>, Error>

Converts an existing AssignedVector of AssignedBytes into a ScannerVec, constraining filler positions to ALPHABET_MAX_SIZE and anchoring the length.

The input elements are already range-checked (they are AssignedBytes). This function computes padding flags and constrains fillers via select.

impl<F> ScannerChip<F>

where F: CircuitField,

pub fn specs_regex(&self, parser: &StdLibParser) -> &Regex

Gets the regex associated to a StdLibParser, as stored in the static library of self.

Trait Implementations

impl<F> Chip<F> for ScannerChip<F>

where F: CircuitField,

type Config = ScannerConfig

A type that holds the configuration for this chip, and any other state it may need during circuit synthesis, that can be derived during Circuit::configure.

type Loaded = ()

A type that holds any general chip state that needs to be loaded at the start of Circuit::synthesize. This might simply be () for some chips.

fn config(&self) -> &Self::Config

The chip holds its own configuration.

fn loaded(&self) -> &Self::Loaded

Provides access to general chip state loaded at the beginning of circuit synthesis.

impl<F> Clone for ScannerChip<F>

where F: CircuitField + Clone,

fn clone(&self) -> ScannerChip<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> ComposableChip<F> for ScannerChip<F>

where F: CircuitField + Ord,

fn load(&self, layouter: &mut impl Layouter<F>) -> Result<(), Error>

Loads the automaton transition table and finalises all deferred substring checks. Must be called at the end of circuit synthesis.

type InstructionDeps = NativeGadget<F, P2RDecompositionChip<F>, NativeChip<F>>

Instruction set dependencies of the chip. This chip will need to be provided with subchips that implement these instructions.

type SharedResources = ([Column<Advice>; 6], Column<Fixed>, HashMap<StdLibParser, (Regex, Automaton), FxBuildHasher>)

Resources that can be used by other chips or gadgets, typically sub-chip configurations and columns.

fn new(config: &ScannerConfig, deps: &Self::InstructionDeps) -> Self

Initialize the chip.

fn configure( meta: &mut ConstraintSystem<F>, shared_res: &Self::SharedResources, ) -> ScannerConfig

Configure the chip. Receives the underlying chips and columns it needs via Self::SharedResources. This method must not allocate any resource in the constraint system that is intended to be shared by other chips.

impl<F> Debug for ScannerChip<F>

where F: CircuitField + Debug,

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

Formats the value using the given formatter.