FieldVar is the core data type in snarky. It is eqivalent to Cvar.t in OCaml. It represents a field element that is part of provable code - either a constant or a variable.

Variables end up filling the witness columns of a constraint system. Think of a variable as a value that has to be provided by the prover, and that has to satisfy all the constraints it is involved in.

Constants end up being hard-coded into the constraint system as gate coefficients. Think of a constant as a value that is known publicly, at compile time, and that defines the constraint system.

Both constants and variables can be combined into an AST using the Add and Scale combinators.

Defined in

lib/field.ts:57

lib/field.ts:65

FlexibleProvable

Ƭ FlexibleProvable<T>: Provable<T> | Struct<T>

Type parameters

Name
`T`

Defined in

lib/circuit_value.ts:60

FlexibleProvablePure

Ƭ FlexibleProvablePure<T>: ProvablePure<T> | StructPure<T>

Type parameters

Name
`T`

Defined in

lib/circuit_value.ts:61

Gate

Ƭ Gate: Object

Type declaration

Name	Type
`coeffs`	`string`[]
`type`	`string`
`wires`	{ `col`: `number` ; `row`: `number` }[]

Defined in

snarky.d.ts:365

Group

Ƭ Group: Group

Defined in

lib/core.ts:61

lib/core.ts:62

InferProvable

Ƭ InferProvable<A>: A extends Constructor<infer U> ? A extends Provable<U> ? U : A extends Struct<U> ? U : InferProvableBase<A> : InferProvableBase<A>

Type parameters

Name
`A`

Defined in

bindings/lib/provable-snarky.ts:277

JsonGate

Ƭ JsonGate: Object

Type declaration

Name	Type
`coeffs`	`number`[][]
`typ`	`string`
`wires`	{ `col`: `number` ; `row`: `number` }[]

Defined in

snarky.d.ts:358

JsonProof

Ƭ JsonProof: Object

Type declaration

Name	Type
`maxProofsVerified`	`0` \| `1` \| `2`
`proof`	`string`
`publicInput`	`string`[]
`publicOutput`	`string`[]

Defined in

lib/proof_system.ts:171

MlPublicKey

Ƭ MlPublicKey: [_: 0, x: FieldConst, isOdd: MlBool]

Defined in

snarky.d.ts:378

MlPublicKeyVar

Ƭ MlPublicKeyVar: [_: 0, x: FieldVar, isOdd: BoolVar]

Defined in

snarky.d.ts:379

Provable

Ƭ Provable<T>: Provable<T>

Provable<T> is the general circuit type interface. It describes how a type T is made up of field elements and auxiliary (non-field element) data.

You will find this as the required input type in a few places in SnarkyJS. One convenient way to create a Provable<T> is using Struct.

Type parameters

Name
`T`

Defined in

lib/provable.ts:45

lib/provable.ts:47

ProvableExtended

Ƭ ProvableExtended<T, TJson>: Provable<T> & ProvableExtension<T, TJson>

Type parameters

Name	Type
`T`	`T`
`TJson`	`any`

Defined in

lib/circuit_value.ts:50

Reducer

Ƭ Reducer<Action>: Object

Type parameters

Name
`Action`

Type declaration

Name	Type
`actionType`	`FlexibleProvablePure`<`Action`>

Defined in

lib/zkapp.ts:1234

lib/zkapp.ts:1553

State

Ƭ State<A>: Object

Gettable and settable state that can be checked for equality.

Type parameters

Name
`A`

Type declaration

Name	Type
`assertEquals`	(`a`: `A`) => `void`
`assertNothing`	() => `void`
`fetch`	() => `Promise`<`undefined` \| `A`>
`fromAppState`	(`appState`: `Field`[]) => `A`
`get`	() => `A`
`getAndAssertEquals`	() => `A`
`set`	(`a`: `A`) => `void`

Defined in

lib/state.ts:73

lib/state.ts:20

Struct

Ƭ Struct<T>: ProvableExtended<NonMethods<T>> & Constructor<T> & { _isStruct: true }

Type parameters

Name
`T`

Defined in

lib/circuit_value.ts:357

lib/circuit_value.ts:55

TransactionStatus

Ƭ TransactionStatus: "INCLUDED" | "PENDING" | "UNKNOWN"

INCLUDED: A transaction that is on the longest chain

PENDING: A transaction either in the transition frontier or in transaction pool but is not on the longest chain

UNKNOWN: The transaction has either been snarked, reached finality through consensus or has been dropped

Defined in

lib/fetch.ts:650

Undefined

Ƭ Undefined: undefined

Defined in

lib/proof_system.ts:57

lib/proof_system.ts:58

Void

Ƭ Void: undefined

Defined in

lib/proof_system.ts:62

lib/proof_system.ts:63

ZkappPublicInput

Ƭ ZkappPublicInput: Object

The public input for zkApps consists of certain hashes of the proving AccountUpdate (and its child accountUpdates) which is constructed during method execution.

For SmartContract proving, a method is run twice: First outside the proof, to obtain the public input, and once in the prover, which takes the public input as input. The current transaction is hashed again inside the prover, which asserts that the result equals the input public input, as part of the snark circuit. The block producer will also hash the transaction they receive and pass it as a public input to the verifier. Thus, the transaction is fully constrained by the proof - the proof couldn't be used to attest to a different transaction.

Type declaration

Name	Type
`accountUpdate`	`Field`
`calls`	`Field`

Defined in

lib/account_update.ts:1965

lib/account_update.ts:1969

Variables

Empty

• Empty: ProvablePureExtended<undefined, null>

Defined in

lib/proof_system.ts:60

lib/proof_system.ts:61

FieldConst

• FieldConst: Object

Type declaration

Name	Type
`-1`	`Uint8Array`
`0`	`Uint8Array`
`1`	`Uint8Array`
`fromBigint`	(`x`: `bigint`) => `Uint8Array`
`toBigint`	(`x`: `Uint8Array`) => `Fp`
`equal`	(`x`: `Uint8Array`, `y`: `Uint8Array`) => `boolean`

Defined in

lib/field.ts:14

lib/field.ts:23

FieldVar

• FieldVar: Object

Type declaration

Name	Type
`-1`	[`Constant`, `Uint8Array`]
`0`	[`Constant`, `Uint8Array`]
`1`	[`Constant`, `Uint8Array`]
`add`	(`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar`
`constant`	(`x`: `bigint` \| `Uint8Array`) => `ConstantFieldVar`
`isConstant`	(`x`: `FieldVar`) => x is ConstantFieldVar
`scale`	(`c`: `Uint8Array`, `x`: `FieldVar`) => `FieldVar`

Defined in

lib/field.ts:57

lib/field.ts:65

Permissions

• Permissions: Object

Type declaration

Name	Type
`allImpossible`	() => `Permissions`
`default`	() => `Permissions`
`dummy`	() => `Permissions`
`fromJSON`	(`permissions`: { `access`: `AuthRequired` ; `editActionState`: `AuthRequired` ; `editState`: `AuthRequired` ; `incrementNonce`: `AuthRequired` ; `receive`: `AuthRequired` ; `send`: `AuthRequired` ; `setDelegate`: `AuthRequired` ; `setPermissions`: `AuthRequired` ; `setTiming`: `AuthRequired` ; `setTokenSymbol`: `AuthRequired` ; `setVerificationKey`: `AuthRequired` ; `setVotingFor`: `AuthRequired` ; `setZkappUri`: `AuthRequired` }) => `Permissions`
`fromString`	(`permission`: `AuthRequired`) => `AuthRequired`
`impossible`	() => `AuthRequired`
`initial`	() => `Permissions`
`none`	() => `AuthRequired`
`proof`	() => `AuthRequired`
`proofOrSignature`	() => `AuthRequired`
`signature`	() => `AuthRequired`

Defined in

lib/account_update.ts:168

lib/account_update.ts:240

Pickles

• Pickles: Object

Type declaration

Name	Type
`compile`	(`rules`: `MlArray`<`Rule`>, `signature`: { `publicInputSize`: `number` ; `publicOutputSize`: `number` }) => { `getVerificationKey`: () => [_: 0, data: string, hash: Uint8Array] ; `provers`: `MlArray`<`Prover`> ; `tag`: `unknown` ; `verify`: (`statement`: `Statement`<`Uint8Array`>, `proof`: `unknown`) => `Promise`<`boolean`> }
`dummyBase64Proof`	() => `string`
`dummyVerificationKey`	() => [_: 0, data: string, hash: Uint8Array]
`proofOfBase64`	(`base64`: `string`, `maxProofsVerified`: `0` \| `2` \| `1`) => [`0` \| `2` \| `1`, `unknown`]
`proofToBase64`	(`proof`: [`0` \| `2` \| `1`, `unknown`]) => `string`
`proofToBase64Transaction`	(`proof`: `unknown`) => `string`
`verify`	(`statement`: `Statement`<`Uint8Array`>, `proof`: `unknown`, `verificationKey`: `string`) => `Promise`<`boolean`>

Defined in

snarky.d.ts:492

snarky.d.ts:510

Poseidon

• Const Poseidon: Object

Type declaration

Name	Type
`Sponge`	typeof `Sponge`
`hash`	(`input`: `Field`[]) => `Field`
`hashToGroup`	(`input`: `Field`[]) => { `x`: `Field` ; `y`: { `x0`: `Field` ; `x1`: `Field` } }
`initialState`	() => [`Field`, `Field`, `Field`]
`update`	(`state`: [`Field`, `Field`, `Field`], `input`: `Field`[]) => [`Field`, `Field`, `Field`]

Defined in

lib/hash.ts:40

Provable

• Provable: Object

Type declaration

Name	Type
`Array`	<A>(`elementType`: `A`, `length`: `number`) => `InferredProvable`<`A`[]>
`asProver`	(`f`: () => `void`) => `void`
`assertEqual`	<T>(`type`: `FlexibleProvable`<`T`>, `x`: `T`, `y`: `T`) => `void`<T>(`x`: `T`, `y`: `T`) => `void`
`constraintSystem`	<T>(`f`: () => `T`) => { `digest`: `string` ; `gates`: `Gate`[] ; `publicInputSize`: `number` ; `result`: `T` ; `rows`: `number` }
`equal`	<T>(`type`: `FlexibleProvable`<`T`>, `x`: `T`, `y`: `T`) => `Bool`<T>(`x`: `T`, `y`: `T`) => `Bool`
`if`	<T>(`condition`: `Bool`, `type`: `FlexibleProvable`<`T`>, `x`: `T`, `y`: `T`) => `T`<T>(`condition`: `Bool`, `x`: `T`, `y`: `T`) => `T`
`inCheckedComputation`	() => `boolean`
`inProver`	() => `boolean`
`log`	(...`args`: `any`) => `void`
`runAndCheck`	(`f`: () => `void`) => `void`
`runUnchecked`	(`f`: () => `void`) => `void`
`switch`	<T, A>(`mask`: `Bool`[], `type`: `A`, `values`: `T`[]) => `T`
`witness`	<T, S>(`type`: `S`, `compute`: () => `T`) => `T`

Defined in

lib/provable.ts:45

lib/provable.ts:47

Snarky

• Snarky: Object

Internal interface to snarky-ml

Note for devs: This module is intended to closely mirror snarky-ml's core, low-level APIs.

Type declaration

Name	Type	Description
`bool`	{ `and`: (`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar` ; `assertEqual`: (`x`: `FieldVar`, `y`: `FieldVar`) => `void` ; `equals`: (`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar` ; `not`: (`x`: `FieldVar`) => `FieldVar` ; `or`: (`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar` }	-
`bool.and`	[object Object]	-
`bool.assertEqual`	[object Object]	-
`bool.equals`	[object Object]	-
`bool.not`	[object Object]	-
`bool.or`	[object Object]	-
`circuit`	{ `keypair`: { `getConstraintSystemJSON`: (`keypair`: `unknown`) => `JsonConstraintSystem` ; `getVerificationKey`: (`keypair`: `unknown`) => `unknown` } ; `compile`: (`main`: `Main`, `publicInputSize`: `number`) => `unknown` ; `prove`: (`main`: `Main`, `publicInputSize`: `number`, `publicInput`: `MlArray`<`Uint8Array`>, `keypair`: `unknown`) => `unknown` ; `verify`: (`publicInput`: `MlArray`<`Uint8Array`>, `proof`: `unknown`, `verificationKey`: `unknown`) => `boolean` }	The circuit API is a low level interface to create zero-knowledge proofs
`circuit.keypair`	{ `getConstraintSystemJSON`: (`keypair`: `unknown`) => `JsonConstraintSystem` ; `getVerificationKey`: (`keypair`: `unknown`) => `unknown` }	-
`circuit.keypair.getConstraintSystemJSON`	[object Object]	Returns a low-level JSON representation of the circuit: a list of gates, each of which represents a row in a table, with certain coefficients and wires to other (row, column) pairs
`circuit.keypair.getVerificationKey`	[object Object]	-
`circuit.compile`	[object Object]	Generates a proving key and a verification key for the provable function `main`
`circuit.prove`	[object Object]	Proves a statement using the private input, public input and the keypair of the circuit.
`circuit.verify`	[object Object]	Verifies a proof using the public input, the proof and the verification key of the circuit.
`field`	{ `add`: (`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar` ; `assertBoolean`: (`x`: `FieldVar`) => `void` ; `assertEqual`: (`x`: `FieldVar`, `y`: `FieldVar`) => `void` ; `assertMul`: (`x`: `FieldVar`, `y`: `FieldVar`, `z`: `FieldVar`) => `void` ; `assertSquare`: (`x`: `FieldVar`, `y`: `FieldVar`) => `void` ; `compare`: (`bitLength`: `number`, `x`: `FieldVar`, `y`: `FieldVar`) => [_: 0, less: FieldVar, lessOrEqual: FieldVar] ; `fromBits`: (`bits`: `MlArray`<`FieldVar`>) => `FieldVar` ; `mul`: (`x`: `FieldVar`, `y`: `FieldVar`) => `FieldVar` ; `readVar`: (`x`: `FieldVar`) => `Uint8Array` ; `scale`: (`c`: `Uint8Array`, `x`: `FieldVar`) => `FieldVar` ; `seal`: (`x`: `FieldVar`) => `FieldVar` ; `toBits`: (`length`: `number`, `x`: `FieldVar`) => `MlArray`<`FieldVar`> ; `toConstantAndTerms`: (`x`: `FieldVar`) => [_: 0, constant: MlOption<Uint8Array>, terms: MlList<MlTuple<Uint8Array, number>>] ; `truncateToBits16`: (`lengthDiv16`: `number`, `x`: `FieldVar`) => `FieldVar` }	APIs to add constraints on field variables
`field.add`	[object Object]	add x, y to get a new AST node Add(x, y); handles if x, y are constants
`field.assertBoolean`	[object Object]	x*x === x without handling of constants
`field.assertEqual`	[object Object]	x === y without handling of constants
`field.assertMul`	[object Object]	x*y === z without handling of constants
`field.assertSquare`	[object Object]	x*x === y without handling of constants
`field.compare`	[object Object]	check x < y and x <= y
`field.fromBits`	[object Object]
`field.mul`	[object Object]	witnesses z = x*y and constrains it with [assert_r1cs]; handles constants
`field.readVar`	[object Object]	evaluates a CVar by walking the AST and reading Vars from a list of public input + aux values
`field.scale`	[object Object]	scale x by a constant to get a new AST node Scale(c, x); handles if x is a constant
`field.seal`	[object Object]	returns a new witness from an AST (implemented with toConstantAndTerms)
`field.toBits`	[object Object]
`field.toConstantAndTerms`	[object Object]	Unfolds AST to get `x = c + c0Var(i0) + ... + cnVar(in)`, returns `(c, [(c0, i0), ..., (cn, in)])`; c is optional
`field.truncateToBits16`	[object Object]	returns x truncated to the lowest `16 * lengthDiv16` bits => can be used to assert that x fits in `16 * lengthDiv16` bits. more efficient than `toBits()` because it uses the EC_endoscalar gate; does 16 bits per row (vs 1 bits per row that you can do with generic gates).
`group`	{ `add`: (`p1`: `MlTuple`<`FieldVar`, `FieldVar`>, `p2`: `MlTuple`<`FieldVar`, `FieldVar`>) => `MlTuple`<`FieldVar`, `FieldVar`> ; `assertOnCurve`: (`p1`: `MlTuple`<`FieldVar`, `FieldVar`>) => `void` ; `equals`: (`p1`: `MlTuple`<`FieldVar`, `FieldVar`>, `p2`: `MlTuple`<`FieldVar`, `FieldVar`>) => `FieldVar` ; `scale`: (`p`: `MlTuple`<`FieldVar`, `FieldVar`>, `s`: `MlArray`<`FieldVar`>) => `MlTuple`<`FieldVar`, `FieldVar`> }	-
`group.add`	[object Object]	Addition of two group elements, handles only variables.
`group.assertOnCurve`	[object Object]	-
`group.equals`	[object Object]	-
`group.scale`	[object Object]	-
`poseidon`	{ `sponge`: { `absorb`: (`sponge`: `unknown`, `x`: `FieldVar`) => `void` ; `create`: (`isChecked`: `boolean`) => `unknown` ; `squeeze`: (`sponge`: `unknown`) => `FieldVar` } ; `hash`: (`input`: `MlArray`<`FieldVar`>, `isChecked`: `boolean`) => `FieldVar` ; `hashToGroup`: (`input`: `MlArray`<`FieldVar`>, `isChecked`: `boolean`) => `MlTuple`<`FieldVar`, `FieldVar`> ; `update`: (`state`: `MlArray`<`FieldVar`>, `input`: `MlArray`<`FieldVar`>, `isChecked`: `boolean`) => [`0`, `FieldVar`, `FieldVar`, `FieldVar`] }	-
`poseidon.sponge`	{ `absorb`: (`sponge`: `unknown`, `x`: `FieldVar`) => `void` ; `create`: (`isChecked`: `boolean`) => `unknown` ; `squeeze`: (`sponge`: `unknown`) => `FieldVar` }	-
`poseidon.sponge.absorb`	[object Object]	-
`poseidon.sponge.create`	[object Object]	-
`poseidon.sponge.squeeze`	[object Object]	-
`poseidon.hash`	[object Object]	-
`poseidon.hashToGroup`	[object Object]	-
`poseidon.update`	[object Object]	-
`asProver`	(`f`: () => `void`) => `void`	Runs code as a prover.
`constraintSystem`	(`f`: () => `void`) => { `digest`: `string` ; `json`: `JsonConstraintSystem` ; `rows`: `number` }	Returns information about the constraint system in the callback function.
`exists`	(`sizeInFields`: `number`, `compute`: () => `MlArray`<`Uint8Array`>) => `MlArray`<`FieldVar`>	witness `sizeInFields` field element variables Note: this is called "exists" because in a proof, you use it like this: > "I prove that there exists x, such that (some statement)"
`existsVar`	(`compute`: () => `Uint8Array`) => `FieldVar`	witness a single field element variable
`runAndCheck`	(`f`: () => `void`) => `void`	Runs code and checks its correctness.
`runUnchecked`	(`f`: () => `void`) => `void`	Runs code in prover mode, without checking correctness.

Defined in

snarky.d.ts:137

snarky.d.ts:149

Test

• Const Test: Object

Type declaration

Name	Type
`encoding`	{ `memoHashBase58`: (`memoBase58`: `string`) => `Uint8Array` ; `memoToBase58`: (`memoString`: `string`) => `string` ; `ofBase58`: (`base58`: `string`, `versionByte`: `number`) => `MlBytes` ; `privateKeyOfBase58`: (`privateKeyBase58`: `string`) => `Uint8Array` ; `privateKeyToBase58`: (`privateKey`: `Uint8Array`) => `string` ; `publicKeyOfBase58`: (`publicKeyBase58`: `string`) => `MlPublicKey` ; `publicKeyToBase58`: (`publicKey`: `MlPublicKey`) => `string` ; `toBase58`: (`s`: `MlBytes`, `versionByte`: `number`) => `string` ; `tokenIdOfBase58`: (`fieldBase58`: `string`) => `Uint8Array` ; `tokenIdToBase58`: (`field`: `Uint8Array`) => `string` }
`encoding.memoHashBase58`	[object Object]
`encoding.memoToBase58`	[object Object]
`encoding.ofBase58`	[object Object]
`encoding.privateKeyOfBase58`	[object Object]
`encoding.privateKeyToBase58`	[object Object]
`encoding.publicKeyOfBase58`	[object Object]
`encoding.publicKeyToBase58`	[object Object]
`encoding.toBase58`	[object Object]
`encoding.tokenIdOfBase58`	[object Object]
`encoding.tokenIdToBase58`	[object Object]
`fieldsFromJson`	{ `accountUpdate`: (`json`: `string`) => `MlArray`<`Uint8Array`> }
`fieldsFromJson.accountUpdate`	[object Object]
`hashFromJson`	{ `accountUpdate`: (`json`: `string`) => `Uint8Array` ; `transactionCommitments`: (`txJson`: `string`) => { `commitment`: `FieldConst` ; `feePayerHash`: `FieldConst` ; `fullCommitment`: `FieldConst` } ; `zkappPublicInput`: (`txJson`: `string`, `accountUpdateIndex`: `number`) => { `accountUpdate`: `FieldConst` ; `calls`: `FieldConst` } }
`hashFromJson.accountUpdate`	[object Object]
`hashFromJson.transactionCommitments`	[object Object]
`hashFromJson.zkappPublicInput`	[object Object]
`hashInputFromJson`	{ `accountPrecondition`: (`json`: `String`) => `MlHashInput` ; `body`: (`json`: `String`) => `MlHashInput` ; `networkPrecondition`: (`json`: `String`) => `MlHashInput` ; `packInput`: (`input`: `MlHashInput`) => `MlArray`<`Uint8Array`> ; `permissions`: (`json`: `String`) => `MlHashInput` ; `timing`: (`json`: `String`) => `MlHashInput` ; `update`: (`json`: `String`) => `MlHashInput` }
`hashInputFromJson.accountPrecondition`	[object Object]
`hashInputFromJson.body`	[object Object]
`hashInputFromJson.networkPrecondition`	[object Object]
`hashInputFromJson.packInput`	[object Object]
`hashInputFromJson.permissions`	[object Object]
`hashInputFromJson.timing`	[object Object]
`hashInputFromJson.update`	[object Object]
`signature`	{ `dummySignature`: () => `string` ; `signFieldElement`: (`messageHash`: `Uint8Array`, `privateKey`: `Uint8Array`, `isMainnet`: `boolean`) => `string` }
`signature.dummySignature`	[object Object]
`signature.signFieldElement`	[object Object]
`tokenId`	{ `derive`: (`publicKey`: `MlPublicKey`, `tokenId`: `Uint8Array`) => `Uint8Array` ; `deriveChecked`: (`publicKey`: `MlPublicKeyVar`, `tokenId`: `FieldVar`) => `FieldVar` }
`tokenId.derive`	[object Object]
`tokenId.deriveChecked`	[object Object]
`transactionHash`	{ `examplePayment`: () => `string` ; `hashPayment`: (`payment`: `string`) => `string` ; `hashPaymentV1`: (`payment`: `string`) => `string` ; `serializeCommon`: (`common`: `string`) => { `data`: `Uint8Array` } ; `serializePayment`: (`payment`: `string`) => { `data`: `Uint8Array` } ; `serializePaymentV1`: (`payment`: `string`) => `string` }
`transactionHash.examplePayment`	[object Object]
`transactionHash.hashPayment`	[object Object]
`transactionHash.hashPaymentV1`	[object Object]
`transactionHash.serializeCommon`	[object Object]
`transactionHash.serializePayment`	[object Object]
`transactionHash.serializePaymentV1`	[object Object]

Defined in

snarky.d.ts:413

TokenId

• Const TokenId: Object

Type declaration

Name	Type
`check`	(`x`: `Field`) => `void`
`default`	`Field`
`fromFields`	(`x`: `Field`[], `aux`: `any`[]) => `Field`
`toAuxiliary`	(`x?`: `Field`) => `any`[]
`toFields`	(`x`: `Field`) => `Field`[]
`toInput`	(`x`: `Field`) => { `fields?`: `Field`[] ; `packed?`: [`Field`, `number`][] }
`derive`	(`tokenOwner`: `PublicKey`, `parentTokenId`: `Field`) => `Field`
`emptyValue`	() => `Field`
`fromBase58`	(`base58`: `string`) => `Field`
`fromJSON`	(`x`: `string`) => `Field`
`sizeInFields`	() => `number`
`toBase58`	(`t`: `Field`) => `string`
`toJSON`	(`x`: `Field`) => `string`

Defined in

lib/account_update.ts:612

Undefined

• Undefined: ProvablePureExtended<undefined, null>

Defined in

lib/proof_system.ts:57

lib/proof_system.ts:58

Void

• Void: ProvablePureExtended<void, null>

Defined in

lib/proof_system.ts:62

lib/proof_system.ts:63

ZkappPublicInput

• ZkappPublicInput: ProvablePure<{ accountUpdate: Field = Field; calls: Field = Field }> & ProvableExtension<{ accountUpdate: Field = Field; calls: Field = Field }, { accountUpdate: string = Field; calls: string = Field }>

Defined in

lib/account_update.ts:1965

lib/account_update.ts:1969

isReady

• isReady: Promise<void>

Deprecated

await isReady is no longer needed. Remove it from your code.

Defined in

index.ts:109

Functions

Account

▸ Account(address, tokenId?): Account

Parameters

Name	Type
`address`	`PublicKey`
`tokenId?`	`Field`

Returns

Account

Defined in

lib/zkapp.ts:1513

Bool

▸ Bool(...args): Bool

A boolean value. You can use it like this:

const x = new Bool(true);

You can also combine multiple booleans via [[not]], [[and]], [[or]].

Use [[assertEquals]] to enforce the value of a Bool.

Parameters

Name	Type
`...args`	[x: boolean \| Bool \| FieldVar]

Returns

Bool

Defined in

lib/core.ts:66

Field

▸ Field(...args): Field

A Field is an element of a prime order finite field. Every other provable type is built using the Field type.

The field is the pasta base field of order 2^254 + 0x224698fc094cf91b992d30ed00000001 (ORDER).

You can create a new Field from everything "field-like" (bigint, integer number, decimal string, Field).

Example

Field(10n); // Field contruction from a big integer
Field(100); // Field construction from a number
Field("1"); // Field construction from a decimal string

Beware: Fields cannot be constructed from fractional numbers or alphanumeric strings:

Field(3.141); // ERROR: Cannot convert a float to a field element
Field("abc"); // ERROR: Invalid argument "abc"

Creating a Field from a negative number can result in unexpected behavior if you are not familiar with modular arithmetic.

Example

const x = Field(-1); // Valid Field construction from negative number
const y = Field(Field.ORDER - 1n); // equivalent to `x`

Important: All the functions defined on a Field (arithmetic, logic, etc.) take their arguments as "field-like". A Field itself is also defined as a "field-like" element.

Parameters

Name	Type
`...args`	[x: string \| number \| bigint \| Uint8Array \| FieldVar \| Field]

Returns

Field

A Field with the value converted from the argument

Defined in

lib/core.ts:66

Group

▸ Group(...args): Group

An element of a Group.

Parameters

Name	Type
`...args`	[{ `x`: `string` \| `number` \| `bigint` \| `FieldVar` \| `Field` ; `y`: `string` \| `number` \| `bigint` \| `FieldVar` \| `Field` }]

Returns

Group

Defined in

lib/core.ts:66

MerkleWitness

▸ MerkleWitness(height): typeof BaseMerkleWitness

Returns a circuit-compatible Witness for a specific Tree height.

Parameters

Name	Type	Description
`height`	`number`	Height of the Merkle Tree that this Witness belongs to.

Returns

typeof BaseMerkleWitness

A circuit-compatible Merkle Witness.

Defined in

lib/merkle_tree.ts:237

Reducer

▸ Reducer<T, A>(reducer): ReducerReturn<A>

Type parameters

Name	Type
`T`	extends `FlexibleProvablePure`<`any`>
`A`	extends `any` = `InferProvable`<`T`>

Parameters

Name	Type
`reducer`	`Object`
`reducer.actionType`	`T`

Returns

ReducerReturn<A>

Defined in

lib/zkapp.ts:1553

State

▸ State<A>(): State<A>

Type parameters

Name
`A`

Returns

State<A>

Defined in

lib/state.ts:73

Struct

▸ Struct<A, T, J, Pure>(type, options?): (value: T) => T & { _isStruct: true } & Pure extends true ? ProvablePure<T> : Provable<T> & { fromJSON: (x: J) => T ; toInput: (x: T) => { fields?: Field[] ; packed?: [Field, number][] } ; toJSON: (x: T) => J }

Struct lets you declare composite types for use in snarkyjs circuits.

These composite types can be passed in as arguments to smart contract methods, used for on-chain state variables or as event / action types.

Here's an example of creating a "Voter" struct, which holds a public key and a collection of votes on 3 different proposals:

let Vote = { hasVoted: Bool, inFavor: Bool };

class Voter extends Struct({
  publicKey: PublicKey,
  votes: [Vote, Vote, Vote]
}) {}

// use Voter as SmartContract input:
class VoterContract extends SmartContract {
  \@method register(voter: Voter) {
    // ...
  }
}

In this example, there are no instance methods on the class. This makes Voter type-compatible with an anonymous object of the form { publicKey: PublicKey, votes: Vote[] }. This mean you don't have to create instances by using new Voter(...), you can operate with plain objects:

voterContract.register({ publicKey, votes });

On the other hand, you can also add your own methods:

class Voter extends Struct({
  publicKey: PublicKey,
  votes: [Vote, Vote, Vote]
}) {
  vote(index: number, inFavor: Bool) {
    let vote = this.votes[i];
    vote.hasVoted = Bool(true);
    vote.inFavor = inFavor;
  }
}

In this case, you'll need the constructor to create instances of Voter. It always takes as input the plain object:

let emptyVote = { hasVoted: Bool(false), inFavor: Bool(false) };
let voter = new Voter({ publicKey, votes: Array(3).fill(emptyVote) });
voter.vote(1, Bool(true));

In addition to creating types composed of Field elements, you can also include auxiliary data which does not become part of the proof. This, for example, allows you to re-use the same type outside snarkyjs methods, where you might want to store additional metadata.

To declare non-proof values of type string, number, etc, you can use the built-in objects String, Number, etc. Here's how we could add the voter's name (a string) as auxiliary data:

class Voter extends Struct({
  publicKey: PublicKey,
  votes: [Vote, Vote, Vote],
  fullName: String
}) {}

Again, it's important to note that this doesn't enable you to prove anything about the fullName string. From the circuit point of view, it simply doesn't exist!

Type parameters

Name	Type
`A`	`A`
`T`	extends `unknown` = `InferProvable`<`A`>
`J`	extends `unknown` = `InferJson`<`A`>
`Pure`	extends `boolean` = `IsPure`<`A`>

Parameters

Name	Type	Description
`type`	`A`	Object specifying the layout of the `Struct`
`options`	`Object`	Advanced option which allows you to force a certain order of object keys
`options.customObjectKeys?`	`string`[]	-

Returns

(value: T) => T & { _isStruct: true } & Pure extends true ? ProvablePure<T> : Provable<T> & { fromJSON: (x: J) => T ; toInput: (x: T) => { fields?: Field[] ; packed?: [Field, number][] } ; toJSON: (x: T) => J }

Class which you can extend

Defined in

lib/circuit_value.ts:357

addCachedAccount

▸ addCachedAccount(partialAccount, graphqlEndpoint?): void

Adds an account to the local cache, indexed by a GraphQL endpoint.

Parameters

Name	Type	Default value
`partialAccount`	`PartialAccount`	`undefined`
`graphqlEndpoint`	`string`	`networkConfig.minaEndpoint`

Returns

void

Defined in

lib/fetch.ts:351

arrayProp

▸ arrayProp<T>(elementType, length): (target: any, key: string) => void

Type parameters

Name
`T`

Parameters

Name	Type
`elementType`	`FlexibleProvable`<`T`>
`length`	`number`

Returns

fn

▸ (target, key): void

Parameters

Name	Type
`target`	`any`
`key`	`string`

Returns

void

Defined in

lib/circuit_value.ts:262

checkZkappTransaction

▸ checkZkappTransaction(txnId): Promise<{ failureReason: string[] ; success: boolean = false } | { failureReason: null = null; success: boolean = true }>

Parameters

Name	Type
`txnId`	`string`

Returns

Promise<{ failureReason: string[] ; success: boolean = false } | { failureReason: null = null; success: boolean = true }>

Defined in

lib/fetch.ts:498

circuitMain

▸ circuitMain(target, propertyName, _descriptor?): any

Parameters

Name	Type
`target`	typeof `Circuit`
`propertyName`	`string`
`_descriptor?`	`PropertyDescriptor`

Returns

any

Defined in

lib/circuit.ts:232

declareMethods

▸ declareMethods<T>(SmartContract, methodArguments): void

declareMethods can be used in place of the @method decorator to declare SmartContract methods along with their list of arguments. It should be placed after the class declaration. Here is an example of declaring a method update, which takes a single argument of type Field:

class MyContract extends SmartContract {
  // ...
  update(x: Field) {
    // ...
  }
}
declareMethods(MyContract, { update: [Field] }); // `[Field]` is the list of arguments!

Note that a method of the same name must still be defined on the class, just without the decorator.

Type parameters

Name	Type
`T`	extends typeof `SmartContract`

Parameters

Name	Type
`SmartContract`	`T`
`methodArguments`	`Record`<`string`, `Provable`<`unknown`>[]>

Returns

void

Defined in

lib/zkapp.ts:1539

declareState

▸ declareState<T>(SmartContract, states): void

declareState can be used in place of the @state decorator to declare on-chain state on a SmartContract. It should be placed after the class declaration. Here is an example of declaring a state property x of type Field.

class MyContract extends SmartContract {
  x = State<Field>();
  // ...
}
declareState(MyContract, { x: Field });

If you're using pure JS, it's not possible to use the built-in class field syntax, i.e. the following will not work:

// THIS IS WRONG IN JS!
class MyContract extends SmartContract {
  x = State();
}
declareState(MyContract, { x: Field });

Instead, add a constructor where you assign the property:

class MyContract extends SmartContract {
  constructor(x) {
    super();
    this.x = State();
  }
}
declareState(MyContract, { x: Field });

Type parameters

Name	Type
`T`	extends typeof `SmartContract`

Parameters

Name	Type
`SmartContract`	`T`
`states`	`Record`<`string`, `FlexibleProvablePure`<`unknown`>>

Returns

void

Defined in

lib/state.ts:163

fetchAccount

▸ fetchAccount(accountInfo, graphqlEndpoint?, «destructured»?): Promise<{ account: Account ; error: undefined } | { account: undefined ; error: FetchError }>

Gets account information on the specified publicKey by performing a GraphQL query to the specified endpoint. This will call the 'GetAccountInfo' query which fetches zkapp related account information.

If an error is returned by the specified endpoint, an error is thrown. Otherwise, the data is returned.

Parameters

Name	Type	Default value	Description
`accountInfo`	`Object`	`undefined`	-
`accountInfo.publicKey`	`string` \| `PublicKey`	`undefined`	-
`accountInfo.tokenId?`	`string` \| `Field`	`undefined`	-
`graphqlEndpoint`	`string`	`networkConfig.minaEndpoint`	The graphql endpoint to fetch from
`«destructured»`	`Object`	`{}`	-
› `timeout`	`undefined` \| `number`	`undefined`	-

Returns

Promise<{ account: Account ; error: undefined } | { account: undefined ; error: FetchError }>

zkapp information on the specified account or an error is thrown

Defined in

lib/fetch.ts:131

fetchEvents

▸ fetchEvents(accountInfo, graphqlEndpoint?, filterOptions?): Promise<{ blockHash: string = event.blockInfo.stateHash; blockHeight: UInt32 ; chainStatus: string = event.blockInfo.chainStatus; events: { data: string[] ; transactionInfo: { hash: string ; memo: string ; status: string } }[] ; globalSlot: UInt32 ; parentBlockHash: string = event.blockInfo.parentHash }[]>

Asynchronously fetches event data for an account from the Mina Archive Node GraphQL API.

Async

Throws

If the GraphQL request fails or the response is invalid.

Example

const accountInfo = { publicKey: 'B62qiwmXrWn7Cok5VhhB3KvCwyZ7NHHstFGbiU5n7m8s2RqqNW1p1wF' };
const events = await fetchEvents(accountInfo);
console.log(events);

Parameters

Name	Type	Default value	Description
`accountInfo`	`Object`	`undefined`	The account information object.
`accountInfo.publicKey`	`string`	`undefined`	The account public key.
`accountInfo.tokenId?`	`string`	`undefined`	The optional token ID for the account.
`graphqlEndpoint?`	`string`	`networkConfig.archiveEndpoint`	The GraphQL endpoint to query. Defaults to the Archive Node GraphQL API.
`filterOptions?`	`EventActionFilterOptions`	`{}`	The optional filter options object.

Returns

Promise<{ blockHash: string = event.blockInfo.stateHash; blockHeight: UInt32 ; chainStatus: string = event.blockInfo.chainStatus; events: { data: string[] ; transactionInfo: { hash: string ; memo: string ; status: string } }[] ; globalSlot: UInt32 ; parentBlockHash: string = event.blockInfo.parentHash }[]>

A promise that resolves to an array of objects containing event data, block information and transaction information for the account.

Defined in

lib/fetch.ts:820

fetchLastBlock

▸ fetchLastBlock(graphqlEndpoint?): Promise<PreconditionBaseTypes<{ blockchainLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; globalSlotSinceGenesis: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; minWindowDensity: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; nextEpochData: { epochLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; ledger: { hash: { isSome: Bool ; value: Field } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } } ; lockCheckpoint: { isSome: Bool ; value: Field } ; seed: { isSome: Bool ; value: Field } ; startCheckpoint: { isSome: Bool ; value: Field } } ; snarkedLedgerHash: { isSome: Bool ; value: Field } ; stakingEpochData: { epochLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; ledger: { hash: { isSome: Bool ; value: Field } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } } ; lockCheckpoint: { isSome: Bool ; value: Field } ; seed: { isSome: Bool ; value: Field } ; startCheckpoint: { isSome: Bool ; value: Field } } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } }>>

Fetches the last block on the Mina network.

Parameters

Name	Type	Default value
`graphqlEndpoint`	`string`	`networkConfig.minaEndpoint`

Returns

Promise<PreconditionBaseTypes<{ blockchainLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; globalSlotSinceGenesis: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; minWindowDensity: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; nextEpochData: { epochLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; ledger: { hash: { isSome: Bool ; value: Field } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } } ; lockCheckpoint: { isSome: Bool ; value: Field } ; seed: { isSome: Bool ; value: Field } ; startCheckpoint: { isSome: Bool ; value: Field } } ; snarkedLedgerHash: { isSome: Bool ; value: Field } ; stakingEpochData: { epochLength: { isSome: Bool ; value: { lower: UInt32 ; upper: UInt32 } } ; ledger: { hash: { isSome: Bool ; value: Field } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } } ; lockCheckpoint: { isSome: Bool ; value: Field } ; seed: { isSome: Bool ; value: Field } ; startCheckpoint: { isSome: Bool ; value: Field } } ; totalCurrency: { isSome: Bool ; value: { lower: UInt64 ; upper: UInt64 } } }>>

Defined in

lib/fetch.ts:394

fetchTransactionStatus

▸ fetchTransactionStatus(txId, graphqlEndpoint?): Promise<TransactionStatus>

Fetches the status of a transaction.

Parameters

Name	Type	Default value
`txId`	`string`	`undefined`
`graphqlEndpoint`	`string`	`networkConfig.minaEndpoint`

Returns

Promise<TransactionStatus>

Defined in

lib/fetch.ts:625

isBool

▸ isBool(x): boolean

Parameters

Name	Type
`x`	`unknown`

Returns

boolean

Defined in

lib/bool.ts:363

isField

▸ isField(x): x is Field

Parameters

Name	Type
`x`	`unknown`

Returns

x is Field

Defined in

lib/field.ts:1232

matrixProp

▸ matrixProp<T>(elementType, nRows, nColumns): (target: any, key: string) => void

Type parameters

Name
`T`

Parameters

Name	Type
`elementType`	`FlexibleProvable`<`T`>
`nRows`	`number`
`nColumns`	`number`

Returns

fn

▸ (target, key): void

Parameters

Name	Type
`target`	`any`
`key`	`string`

Returns

void

Defined in

lib/circuit_value.ts:271

method

▸ method<T>(target, methodName, descriptor): void

A decorator to use in a zkApp to mark a method as callable by anyone. You can use inside your zkApp class as:

\@method myMethod(someArg: Field) {
  // your code here
}

Type parameters

Name	Type
`T`	extends `SmartContract`<`T`>

Parameters

Name	Type
`target`	`T` & { `constructor`: `any` }
`methodName`	keyof `T` & `string`
`descriptor`	`PropertyDescriptor`

Returns

void

Defined in

lib/zkapp.ts:85

prop

▸ prop(this, target, key): void

Parameters

Name	Type
`this`	`any`
`target`	`any`
`key`	`string`

Returns

void

Defined in

lib/circuit_value.ts:247

provable

▸ provable<A>(typeObj, options?): ProvableExtended<InferProvable<A>, InferJson<A>>

Type parameters

Name
`A`

Parameters

Name	Type
`typeObj`	`A`
`options?`	`Object`
`options.customObjectKeys?`	`string`[]
`options.isPure?`	`boolean`

Returns

ProvableExtended<InferProvable<A>, InferJson<A>>

Defined in

bindings/lib/provable-snarky.ts:47

provablePure

▸ provablePure<A>(typeObj, options?): ProvablePure<InferProvable<A>> & ProvableExtension<InferProvable<A>, InferJson<A>>

Type parameters

Name
`A`

Parameters

Name	Type
`typeObj`	`A`
`options`	`Object`
`options.customObjectKeys?`	`string`[]

Returns

ProvablePure<InferProvable<A>> & ProvableExtension<InferProvable<A>, InferJson<A>>

Defined in

bindings/lib/provable-snarky.ts:224

public_

▸ public_(target, _key, index): void

Parameters

Name	Type
`target`	`any`
`_key`	`string` \| `symbol`
`index`	`number`

Returns

void

Defined in

lib/circuit.ts:196

scaleShifted

▸ scaleShifted(point, shiftedScalar): Group

Parameters

Name	Type
`point`	`Group`
`shiftedScalar`	`Scalar`

Returns

Group

Defined in

lib/signature.ts:296

sendZkapp

▸ sendZkapp(json, graphqlEndpoint?, «destructured»?): Promise<[FetchResponse, undefined] | [undefined, FetchError]>

Sends a zkApp command (transaction) to the specified GraphQL endpoint.

Parameters

Name	Type	Default value
`json`	`string`	`undefined`
`graphqlEndpoint`	`string`	`networkConfig.minaEndpoint`
`«destructured»`	`Object`	`{}`
› `timeout`	`undefined` \| `number`	`undefined`

Returns

Promise<[FetchResponse, undefined] | [undefined, FetchError]>

Defined in

lib/fetch.ts:655

setArchiveGraphqlEndpoint

▸ setArchiveGraphqlEndpoint(graphqlEndpoint): void

Sets up a GraphQL endpoint to be used for fetching information from an Archive Node.

Parameters

Name	Type
`graphqlEndpoint`	`string`

Returns

void

Defined in

lib/fetch.ts:100

setGraphqlEndpoint

▸ setGraphqlEndpoint(graphqlEndpoint): void

Parameters

Name	Type
`graphqlEndpoint`	`string`

Returns

void

Defined in

lib/fetch.ts:78

setGraphqlEndpoints

▸ setGraphqlEndpoints(«destructured»): void

Parameters

Name	Type
`«destructured»`	`string`[]

Returns

void

Defined in

lib/fetch.ts:71

shutdown

▸ shutdown(): void

Deprecated

shutdown() is no longer needed, and is a no-op. Remove it from your code.

Returns

void

Defined in

index.ts:114

state

▸ state<A>(stateType): (target: SmartContract & { constructor: any }, key: string, _descriptor?: PropertyDescriptor) => void

A decorator to use within a zkapp to indicate what will be stored on-chain. For example, if you want to store a field element some_state in a zkapp, you can use the following in the declaration of your zkapp:

@state(Field) some_state = State<Field>();

Type parameters

Name
`A`

Parameters

Name	Type
`stateType`	`FlexibleProvablePure`<`A`>

Returns

fn

▸ (target, key, _descriptor?): void

Parameters

Name	Type
`target`	`SmartContract` & { `constructor`: `any` }
`key`	`string`
`_descriptor?`	`PropertyDescriptor`

Returns

void

Defined in

lib/state.ts:87

verify

▸ verify(proof, verificationKey): Promise<boolean>

Parameters

Name	Type
`proof`	`JsonProof` \| `Proof`<`any`, `any`>
`verificationKey`	`string`

Returns

Promise<boolean>

Defined in

lib/proof_system.ts:137

withMessage

▸ withMessage(error, message?): unknown

Parameters

Name	Type
`error`	`unknown`
`message?`	`string`

Returns

unknown

Defined in

lib/field.ts:1254

SnarkyJS

Table of contents​

Namespaces​

Enumerations​

Classes​

Interfaces​

Type Aliases​

Variables​

Functions​

Type Aliases​

Bool​

Defined in​

BoolVar​

Defined in​

ConstantField​

Defined in​

DeployArgs​

Defined in​

Empty​

Defined in​

Field​

Defined in​

FieldConst​

Defined in​

FieldVar​

Defined in​

FlexibleProvable​

Type parameters​

Defined in​

FlexibleProvablePure​

Type parameters​

Defined in​

Gate​

Type declaration​

Defined in​

Group​

Defined in​

InferProvable​

Type parameters​

Defined in​

JsonGate​

Type declaration​

Defined in​

JsonProof​

Type declaration​

Defined in​

MlPublicKey​

Defined in​

MlPublicKeyVar​

Defined in​

Provable​

Type parameters​

Defined in​

ProvableExtended​

Type parameters​

Defined in​

Reducer​

Type parameters​

Type declaration​

Defined in​

State​

Type parameters​

Type declaration​

Defined in​

Struct​

Type parameters​

Defined in​

TransactionStatus​

Defined in​

Undefined​

Defined in​

Void​

Defined in​

ZkappPublicInput​

Type declaration​

Defined in​

Variables​

Empty​

Defined in​

FieldConst​

Table of contents

Namespaces

Enumerations

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

Bool

Defined in

BoolVar

Defined in

ConstantField

Defined in

DeployArgs

Defined in

Empty

Defined in

Field

Defined in

FieldConst

Defined in

FieldVar

Defined in

FlexibleProvable

Type parameters

Defined in

FlexibleProvablePure

Type parameters

Defined in

Gate

Type declaration

Defined in

Group

Defined in

InferProvable

Type parameters

Defined in

JsonGate

Type declaration

Defined in

JsonProof

Type declaration

Defined in

MlPublicKey

Defined in

MlPublicKeyVar

Defined in

Provable

Type parameters

Defined in

ProvableExtended

Type parameters

Defined in

Reducer

Type parameters

Type declaration

Defined in

State

Type parameters

Type declaration

Defined in

Struct

Type parameters

Defined in

TransactionStatus

Defined in

Undefined

Defined in

Void

Defined in

ZkappPublicInput

Type declaration

Defined in

Variables

Empty

Defined in

FieldConst

Type declaration