Struct ark_r1cs_std::bits::uint8::UInt8

pub struct UInt8<F: Field> { /* fields omitted */ }

Represents an interpretation of 8 Boolean objects as an unsigned integer.

Implementations

impl<F: Field> UInt8<F>

pub fn constant_vec(values: &[u8]) -> Vec<Self>

Construct a constant vector of UInt8 from a vector of u8

This does not create any new variables or constraints.

// We'll use the BLS12-381 scalar field for our constraints.
use ark_test_curves::bls12_381::Fr;
use ark_relations::r1cs::*;
use ark_r1cs_std::prelude::*;

let cs = ConstraintSystem::<Fr>::new_ref();
let var = vec![UInt8::new_witness(cs.clone(), || Ok(2))?];

let constant = UInt8::constant_vec(&[2]);
var.enforce_equal(&constant)?;
assert!(cs.is_satisfied().unwrap());

pub fn constant(value: u8) -> Self

Construct a constant UInt8 from a u8

This does not create new variables or constraints.

// We'll use the BLS12-381 scalar field for our constraints.
use ark_test_curves::bls12_381::Fr;
use ark_relations::r1cs::*;
use ark_r1cs_std::prelude::*;

let cs = ConstraintSystem::<Fr>::new_ref();
let var = UInt8::new_witness(cs.clone(), || Ok(2))?;

let constant = UInt8::constant(2);
var.enforce_equal(&constant)?;
assert!(cs.is_satisfied().unwrap());

pub fn new_witness_vec(
    cs: impl Into<Namespace<F>>,
    values: &[impl Into<Option<u8>> + Copy]
) -> Result<Vec<Self>, SynthesisError>

Allocates a slice of u8’s as private witnesses.

pub fn new_input_vec(
    cs: impl Into<Namespace<F>>,
    values: &[u8]
) -> Result<Vec<Self>, SynthesisError> where
    F: PrimeField, 

Allocates a slice of u8’s as public inputs by first packing them into elements of F, (thus reducing the number of input allocations), allocating these elements as public inputs, and then converting these field variables FpVar<F> variables back into bytes.

From a user perspective, this trade-off adds constraints, but improves verifier time and verification key size.

// We'll use the BLS12-381 scalar field for our constraints.
use ark_test_curves::bls12_381::Fr;
use ark_relations::r1cs::*;
use ark_r1cs_std::prelude::*;

let cs = ConstraintSystem::<Fr>::new_ref();
let two = UInt8::new_witness(cs.clone(), || Ok(2))?;
let var = vec![two.clone(); 32];

let c = UInt8::new_input_vec(cs.clone(), &[2; 32])?;
var.enforce_equal(&c)?;
assert!(cs.is_satisfied().unwrap());

pub fn from_bits_le(bits: &[Boolean<F>]) -> Self

Converts a little-endian byte order representation of bits into a UInt8.

// We'll use the BLS12-381 scalar field for our constraints.
use ark_test_curves::bls12_381::Fr;
use ark_relations::r1cs::*;
use ark_r1cs_std::prelude::*;

let cs = ConstraintSystem::<Fr>::new_ref();
let var = UInt8::new_witness(cs.clone(), || Ok(128))?;

let f = Boolean::FALSE;
let t = Boolean::TRUE;

// Construct [0, 0, 0, 0, 0, 0, 0, 1]
let mut bits = vec![f.clone(); 7];
bits.push(t);

let mut c = UInt8::from_bits_le(&bits);
var.enforce_equal(&c)?;
assert!(cs.is_satisfied().unwrap());

pub fn xor(&self, other: &Self) -> Result<Self, SynthesisError>

Outputs self ^ other.

If at least one of self and other are constants, then this method does not create any constraints or variables.

// We'll use the BLS12-381 scalar field for our constraints.
use ark_test_curves::bls12_381::Fr;
use ark_relations::r1cs::*;
use ark_r1cs_std::prelude::*;

let cs = ConstraintSystem::<Fr>::new_ref();
let a = UInt8::new_witness(cs.clone(), || Ok(16))?;
let b = UInt8::new_witness(cs.clone(), || Ok(17))?;
let c = UInt8::new_witness(cs.clone(), || Ok(1))?;

a.xor(&b)?.enforce_equal(&c)?;
assert!(cs.is_satisfied().unwrap());

Trait Implementations

impl<ConstraintF: Field> AllocVar<u8, ConstraintF> for UInt8<ConstraintF>

fn new_variable<T: Borrow<u8>>(
    cs: impl Into<Namespace<ConstraintF>>,
    f: impl FnOnce() -> Result<T, SynthesisError>,
    mode: AllocationMode
) -> Result<Self, SynthesisError>

Allocates a new variable of type Self in the ConstraintSystem cs. The mode of allocation is decided by mode.

fn new_constant(
    cs: impl Into<Namespace<F>>,
    t: impl Borrow<V>
) -> Result<Self, SynthesisError>

Allocates a new constant of type Self in the ConstraintSystem cs.

fn new_input<T: Borrow<V>>(
    cs: impl Into<Namespace<F>>,
    f: impl FnOnce() -> Result<T, SynthesisError>
) -> Result<Self, SynthesisError>

Allocates a new public input of type Self in the ConstraintSystem cs.

fn new_witness<T: Borrow<V>>(
    cs: impl Into<Namespace<F>>,
    f: impl FnOnce() -> Result<T, SynthesisError>
) -> Result<Self, SynthesisError>

Allocates a new private witness of type Self in the ConstraintSystem cs.

impl<F: Clone + Field> Clone for UInt8<F>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ConstraintF: Field> CondSelectGadget<ConstraintF> for UInt8<ConstraintF>

fn conditionally_select(
    cond: &Boolean<ConstraintF>,
    true_value: &Self,
    false_value: &Self
) -> Result<Self, SynthesisError>

If cond == &Boolean::TRUE, then this returns true_value; else, returns false_value.

fn conditionally_select_power_of_two_vector(
    position: &[Boolean<ConstraintF>],
    values: &[Self]
) -> Result<Self, SynthesisError>

Returns an element of values whose index in represented by position. position is an array of boolean that represents an unsigned integer in big endian order.

impl<F: Debug + Field> Debug for UInt8<F>

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

Formats the value using the given formatter.

impl<ConstraintF: Field> EqGadget<ConstraintF> for UInt8<ConstraintF>

fn is_eq(&self, other: &Self) -> Result<Boolean<ConstraintF>, SynthesisError>

Output a Boolean value representing whether self.value() == other.value().

fn conditional_enforce_equal(
    &self,
    other: &Self,
    condition: &Boolean<ConstraintF>
) -> Result<(), SynthesisError>

If should_enforce == true, enforce that self and other are equal; else, enforce a vacuously true statement.

fn conditional_enforce_not_equal(
    &self,
    other: &Self,
    condition: &Boolean<ConstraintF>
) -> Result<(), SynthesisError>

If should_enforce == true, enforce that self and other are not equal; else, enforce a vacuously true statement.

fn is_neq(&self, other: &Self) -> Result<Boolean<F>, SynthesisError>

Output a Boolean value representing whether self.value() != other.value().

fn enforce_equal(&self, other: &Self) -> Result<(), SynthesisError>

Enforce that self and other are equal.

fn enforce_not_equal(&self, other: &Self) -> Result<(), SynthesisError>

Enforce that self and other are not equal.

impl<F: Field> R1CSVar<F> for UInt8<F>

type Value = u8

The type of the “native” value that Self represents in the constraint system.

fn cs(&self) -> ConstraintSystemRef<F>

Returns the underlying ConstraintSystemRef.

fn value(&self) -> Result<Self::Value, SynthesisError>

Returns the value that is assigned to self in the underlying ConstraintSystem.

fn is_constant(&self) -> bool

Returns true if self is a circuit-generation-time constant.

impl<F: Field> ToBitsGadget<F> for UInt8<F>

fn to_bits_le(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs the canonical little-endian bit-wise representation of self.

fn to_non_unique_bits_le(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs a possibly non-unique little-endian bit-wise representation of self.

fn to_bits_be(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs the canonical big-endian bit-wise representation of self.

fn to_non_unique_bits_be(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs a possibly non-unique big-endian bit-wise representation of self.