Struct halo2_gadgets::sinsemilla::merkle::chip::MerkleChip

pub struct MerkleChip<Hash, Commit, Fixed>where
    Hash: HashDomains<Affine>,
    Fixed: FixedPoints<Affine>,
    Commit: CommitDomains<Affine, Fixed, Hash>,{ /* private fields */ }

Chip implementing MerkleInstructions.

This chip specifically implements MerkleInstructions::hash_layer as the MerkleCRH function hash = SinsemillaHash(Q, 𝑙⋆ || left⋆ || right⋆), where:

• 𝑙⋆ = I2LEBSP_10(l)
• left⋆ = I2LEBSP_255(left)
• right⋆ = I2LEBSP_255(right)

This chip does NOT constrain left⋆ and right⋆ to be canonical encodings of left and right.

Implementations

impl<Hash, Commit, F> MerkleChip<Hash, Commit, F>where Hash: HashDomains<Affine>, F: FixedPoints<Affine>, Commit: CommitDomains<Affine, F, Hash>,

pub fn configure( meta: &mut ConstraintSystem<Base>, sinsemilla_config: SinsemillaConfig<Hash, Commit, F> ) -> MerkleConfig<Hash, Commit, F>

Configures the MerkleChip.

pub fn construct(config: MerkleConfig<Hash, Commit, F>) -> Self

Constructs a MerkleChip given a MerkleConfig.

Trait Implementations

impl<Hash, Commit, Fixed> Chip<Fp> for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine>, Fixed: FixedPoints<Affine>, Commit: CommitDomains<Affine, Fixed, Hash>,

type Config = MerkleConfig<Hash, Commit, Fixed>

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<Hash, Commit, Fixed> Clone for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine> + Clone, Fixed: FixedPoints<Affine> + Clone, Commit: CommitDomains<Affine, Fixed, Hash> + Clone,

fn clone(&self) -> MerkleChip<Hash, Commit, Fixed>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash, Commit, F> CondSwapInstructions<Fp> for MerkleChip<Hash, Commit, F>where Hash: HashDomains<Affine>, F: FixedPoints<Affine>, Commit: CommitDomains<Affine, F, Hash>,

fn swap( &self, layouter: impl Layouter<Base>, pair: (Self::Var, Value<Base>), swap: Value<bool> ) -> Result<(Self::Var, Self::Var), Error>

Given an input pair (a,b) and a swap boolean flag, returns (b,a) if swap is set, else (a,b) if swap is not set.

impl<Hash, Commit, Fixed> Debug for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine> + Debug, Fixed: FixedPoints<Affine> + Debug, Commit: CommitDomains<Affine, Fixed, Hash> + Debug,

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

Formats the value using the given formatter.

impl<Hash, Commit, F, const MERKLE_DEPTH: usize> MerkleInstructions<EpAffine, MERKLE_DEPTH, { sinsemilla::K }, { sinsemilla::C }> for MerkleChip<Hash, Commit, F>where Hash: HashDomains<Affine> + Eq, F: FixedPoints<Affine>, Commit: CommitDomains<Affine, F, Hash> + Eq,

fn hash_layer( &self, layouter: impl Layouter<Base>, Q: Affine, l: usize, left: Self::Var, right: Self::Var ) -> Result<Self::Var, Error>

Compute MerkleCRH for a given layer. The hash that computes the root is at layer 0, and the hashes that are applied to two leaves are at layer MERKLE_DEPTH - 1 = layer 31.

impl<Hash, Commit, Fixed> PartialEq<MerkleChip<Hash, Commit, Fixed>> for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine> + PartialEq, Fixed: FixedPoints<Affine> + PartialEq, Commit: CommitDomains<Affine, Fixed, Hash> + PartialEq,

fn eq(&self, other: &MerkleChip<Hash, Commit, Fixed>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Hash, Commit, F> SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }> for MerkleChip<Hash, Commit, F>where Hash: HashDomains<Affine>, F: FixedPoints<Affine>, Commit: CommitDomains<Affine, F, Hash>,

type CellValue = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::CellValue

A variable in the circuit.

type Message = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::Message

A message composed of Self::MessagePieces.

type MessagePiece = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::MessagePiece

A piece in a message containing a number of K-bit words. A Self::MessagePiece fits in a single base field element, which means it can only contain up to N words, where N*K <= C::Base::CAPACITY.

type RunningSum = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::RunningSum

A cumulative sum z is used to decompose a Sinsemilla message. It produces intermediate values for each word in the message, such that z_next = (z_cur - word_next) / 2^K.

type X = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::X

The x-coordinate of a point output of Self::hash_to_point.

type NonIdentityPoint = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::NonIdentityPoint

A point output of Self::hash_to_point.

type FixedPoints = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::FixedPoints

A type enumerating the fixed points used in CommitDomains.

type HashDomains = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::HashDomains

HashDomains used in this instruction.

type CommitDomains = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<EpAffine, { sinsemilla::K }, { sinsemilla::C }>>::CommitDomains

CommitDomains used in this instruction.

fn witness_message_piece( &self, layouter: impl Layouter<Base>, value: Value<Base>, num_words: usize ) -> Result<Self::MessagePiece, Error>

Witness a message piece given a field element. Returns a Self::MessagePiece encoding the given message.

fn hash_to_point( &self, layouter: impl Layouter<Base>, Q: Affine, message: Self::Message ) -> Result<(Self::NonIdentityPoint, Vec<Vec<Self::CellValue>>), Error>

Hashes a message to an ECC curve point. This returns both the resulting point, as well as the message decomposition in the form of intermediate values in a cumulative sum.

fn extract(point: &Self::NonIdentityPoint) -> Self::X

Extracts the x-coordinate of the output of a Sinsemilla hash.

impl<Hash, Commit, F> UtilitiesInstructions<Fp> for MerkleChip<Hash, Commit, F>where Hash: HashDomains<Affine>, F: FixedPoints<Affine>, Commit: CommitDomains<Affine, F, Hash>,

type Var = AssignedCell<Fp, Fp>

Variable in the circuit.

fn load_private( &self, layouter: impl Layouter<F>, column: Column<Advice>, value: Value<F> ) -> Result<Self::Var, Error>

Load a variable.

impl<Hash, Commit, Fixed> Eq for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine> + Eq, Fixed: FixedPoints<Affine> + Eq, Commit: CommitDomains<Affine, Fixed, Hash> + Eq,

impl<Hash, Commit, Fixed> StructuralEq for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine>, Fixed: FixedPoints<Affine>, Commit: CommitDomains<Affine, Fixed, Hash>,

impl<Hash, Commit, Fixed> StructuralPartialEq for MerkleChip<Hash, Commit, Fixed>where Hash: HashDomains<Affine>, Fixed: FixedPoints<Affine>, Commit: CommitDomains<Affine, Fixed, Hash>,