Provable
Interface: Provable<T>
Provable<T>
is the general circuit type interface in o1js. Provable<T>
interface describes how a type T
is made up of Field elements and "auxiliary" (non-provable) data.
Provable<T>
is the required input type in a few places in o1js. One convenient way to create a Provable<T>
is using Struct
.
The properties and methods on the provable type exist in all base o1js types as well (aka. Field, Bool, etc.). In most cases, a zkApp developer does not need these functions to create zkApps.
Type parameters
Name |
---|
T |
Hierarchy
Provable
Table of contents
Properties
Methods
Properties
check
• check: (value
: T
) => void
Type declaration
▸ (value
): void
Add assertions to the proof to check if value
is a valid member of type T
.
This function does not return anything, instead it creates any number of assertions to prove that value
is a valid member of the type T
.
For instance, calling check function on the type Bool asserts that the value of the element is either 1 or 0.
Parameters
Name | Type | Description |
---|---|---|
value | T | the element of type T to put assertions on. |
Returns
void
Defined in
fromFields
• fromFields: (fields
: Field
[], aux
: any
[]) => T
Type declaration
▸ (fields
, aux
): T
A function that returns an element of type T
from the given provable and "auxiliary" data.
Important: For any element of type T
, this function is the reverse operation of calling toFields and toAuxilary methods on an element of type T
.
Parameters
Name | Type | Description |
---|---|---|
fields | Field [] | an array of Field elements describing the provable data of the new T element. |
aux | any [] | an array of any type describing the "auxiliary" data of the new T element, optional. |
Returns
T
An element of type T
generated from the given provable and "auxiliary" data.
Defined in
toAuxiliary
• toAuxiliary: (value?
: T
) => any
[]
Type declaration
▸ (value?
): any
[]
A function that takes value
(optional), an element of type T
, as argument and returns an array of any type that make up the "auxiliary" (non-provable) data of value
.
Parameters
Name | Type | Description |
---|---|---|
value? | T | the element of type T to generate the auxiliary data array from, optional. If not provided, a default value for auxiliary data is returned. |
Returns
any
[]
An array of any type describing how this T
element is made up of "auxiliary" (non-provable) data.
Defined in
toFields
• toFields: (value
: T
) => Field
[]
Type declaration
▸ (value
): Field
[]
A function that takes value
, an element of type T
, as argument and returns an array of Field elements that make up the provable data of value
.
Parameters
Name | Type | Description |
---|---|---|
value | T | the element of type T to generate the Field array from. |
Returns
Field
[]
A Field array describing how this T
element is made up of Field elements.
Defined in
Methods
sizeInFields
▸ sizeInFields(): number
Return the size of the T
type in terms of Field type, as Field is the primitive type.
Warning: This function returns a number
, so you cannot use it to prove something on chain. You can use it during debugging or to understand the memory complexity of some type.
Returns
number
A number
representing the size of the T
type in terms of Field type.