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

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

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

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: &MerkleChip<Hash, Commit, Fixed>) -> bool

This method tests for !=.

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

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>,