frontend

type API interface {

	// Add returns res = i1+i2+...in
	Add(i1, i2 interface{}, in ...interface{}) Variable

	// Sub returns res = i1 - i2 - ...in
	Sub(i1, i2 interface{}, in ...interface{}) Variable

	// Neg returns -i
	Neg(i1 interface{}) Variable

	// Mul returns res = i1 * i2 * ... in
	Mul(i1, i2 interface{}, in ...interface{}) Variable

	// DivUnchecked returns i1 / i2 . if i1 == i2 == 0, returns 0
	DivUnchecked(i1, i2 interface{}) Variable

	// Div returns i1 / i2
	Div(i1, i2 interface{}) Variable

	// Inverse returns res = 1 / i1
	Inverse(i1 interface{}) Variable

	// ToBinary unpacks a variable in binary,
	// n is the number of bits to select (starting from lsb)
	// n default value is fr.Bits the number of bits needed to represent a field element
	//
	// The result in in little endian (first bit= lsb)
	ToBinary(i1 interface{}, n ...int) []Variable

	// FromBinary packs b, seen as a fr.Element in little endian
	FromBinary(b ...Variable) Variable

	// Xor returns a ^ b
	// a and b must be 0 or 1
	Xor(a, b Variable) Variable

	// Or returns a | b
	// a and b must be 0 or 1
	Or(a, b Variable) Variable

	// Or returns a & b
	// a and b must be 0 or 1
	And(a, b Variable) Variable

	// Select if b is true, yields i1 else yields i2
	Select(b interface{}, i1, i2 interface{}) Variable

	// IsZero returns 1 if a is zero, 0 otherwise
	IsZero(i1 interface{}) Variable

	// AssertIsEqual fails if i1 != i2
	AssertIsEqual(i1, i2 interface{})

	// AssertIsDifferent fails if i1 == i2
	AssertIsDifferent(i1, i2 interface{})

	// AssertIsBoolean fails if v != 0 || v != 1
	AssertIsBoolean(i1 interface{})

	// AssertIsLessOrEqual fails if  v > bound
	AssertIsLessOrEqual(v Variable, bound interface{})

	// Println behaves like fmt.Println but accepts frontend.Variable as parameter
	// whose value will be resolved at runtime when computed by the solver
	Println(a ...interface{})

	// Constant returns a frontend.Variable representing a known value at compile time
	Constant(input interface{}) Variable

	// NewHint initialize a variable whose value will be evaluated using the provided hint function at run time
	//
	// hint function is provided at proof creation time and must match the hintID
	// inputs must be either variables or convertible to big int
	// /!\ warning /!\
	// this doesn't add any constraint to the newly created wire
	// from the backend point of view, it's equivalent to a user-supplied witness
	// except, the solver is going to assign it a value, not the caller
	NewHint(f hint.Function, inputs ...interface{}) Variable
}

type Circuit interface {
	// Define declares the circuit's Constraints
	Define(curveID ecc.ID, api API) error
}

type CompileOption struct {
	// contains filtered or unexported fields
}

type CompiledConstraintSystem interface {
	io.WriterTo
	io.ReaderFrom

	// GetNbVariables return number of internal, secret and public variables
	GetNbVariables() (internal, secret, public int)
	GetNbConstraints() int
	GetNbCoefficients() int

	CurveID() ecc.ID
	FrSize() int

	// ToHTML generates a human readable representation of the constraint system
	ToHTML(w io.Writer) error
}

type Variable struct {
	WitnessValue interface{} // witness usage only
	// contains filtered or unexported fields
}