Class EdDSAPoseidon
Index
Constructors
Properties
Methods
Constructors
constructor
- new
EdDSAPoseidon(privateKey?): EdDSAPoseidon Initializes a new instance, deriving necessary cryptographic parameters from the provided private key. +If the private key is not passed as a parameter, a random 32-byte hexadecimal key is generated.
+The private key must be an instance of Buffer, Uint8Array or a string. The input will be used to +generate entropy and there is no limit in size. +The string is used as a set of raw bytes (in UTF-8) and is typically used to pass passwords or secret messages. +If you want to pass a bigint, a number or a hexadecimal, be sure to convert them to one of the supported types first. +The 'conversions' module in @zk-kit/utils provides a set of functions that may be useful in case you need to convert types.
+Parameters
- privateKey: string | Uint8Array | Buffer = ...
The private key used for signing and public key derivation.
+
Returns EdDSAPoseidon
- privateKey: string | Uint8Array | Buffer = ...
Properties
packed
packed
private
private
public
secret
secret
Methods
sign
- sign
Message(message): Signature<bigint> Signs a given message using the private key and returns the signature.
+Parameters
- message: BigNumberish
The message to be signed.
+
Returns Signature<bigint>
The signature of the message.
+- message: BigNumberish
verify
- verify
Signature(message, signature): boolean Verifies a signature against a message and the public key stored in this instance.
+Parameters
- message: BigNumberish
The message whose signature is to be verified.
+ - signature: Signature
The signature to be verified.
+
Returns boolean
True if the signature is valid for the message and public key, false otherwise.
+- message: BigNumberish
Class IMT
An IMT (aka Incremental Merkle Tree) is a type of data structure used in cryptography and +computer science for efficiently verifying the integrity of a large set of data, +especially in situations where new data is added over time. It is based on the concept +of a Merkle tree, and its key feature is its ability to efficiently update the tree +when new data is added or existing data is modified. +In this implementation, the tree is constructed using a fixed IMT#depth +value, and a list of IMT#zeroes (one for each level) is used to compute the +hash of a node when not all of its children are defined. The number of children for each +node can also be specified with the IMT#arity parameter.
+ Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
- new IMT(hash, depth, zeroValue, arity?, leaves?): IMT
It initializes the tree with an hash function, the depth, the zero value to use for zeroes +and the arity (i.e. the number of children for each node). It also takes an optional parameter +to initialize the tree with a list of leaves.
+Parameters
- hash: IMTHashFunction
The hash function used to create nodes.
+ - depth: number
The tree depth.
+ - zeroValue: any
The zero value used to create zeroes.
+ - arity: number = 2
The number of children for each node.
+ - leaves: any[] = []
The list of initial leaves.
+
Returns IMT
- hash: IMTHashFunction
Properties
Private Readonly _arity
_arity: number
The number of children per node.
+Private Readonly _depth
_depth: number
The depth of the tree, which is the number of edges from the node to the +tree's root node.
+Private Readonly _hash
The hash function used to compute the tree nodes.
+Private Readonly _nodes
_nodes: any[][]
The matrix where all the tree nodes are stored. The first index indicates +the level of the tree, while the second index represents the node's +position within that specific level.
+Private Readonly _zeroes
_zeroes: any[]
A list of zero values calculated during the initialization of the tree. +The list contains one value for each level of the tree, and the value for +a given level is equal to the hash of the previous level's value. +The first value is the zero hash provided by the user. +These values are used to calculate the hash of a node in case some of its +children are missing.
+Accessors
arity
- get arity(): number
The number of children per node.
+Returns number
The number of children per node.
+
depth
- get depth(): number
The depth of the tree, which equals the number of levels - 1.
+Returns number
The depth of the tree.
+
leaves
- get leaves(): any[]
The leaves of the tree. They can be retrieved from the first +level of the tree using IMT#_nodes. The returned +value is a copy of the array and not the original object.
+Returns any[]
The list of tree leaves.
+
root
- get root(): any
The root of the tree. This value doesn't need to be stored as +it is always the first and unique element of the last level of the tree. +Its value can be retrieved in IMT#_nodes.
+Returns any
The root hash of the tree.
+
zeroes
- get zeroes(): any[]
The list of zero values calculated during the initialization of the tree.
+Returns any[]
The list of pre-computed zeroes.
+
Methods
create
- create
Proof(index): IMTMerkleProof It creates a IMTMerkleProof for a leaf of the tree. +That proof can be verified by this tree using the same hash function.
+Parameters
- index: number
The index of the leaf for which a Merkle proof will be generated.
+
Returns IMTMerkleProof
The Merkle proof of the leaf.
+- index: number
delete
index
insert
- insert(leaf): void
The leaves are inserted incrementally. If 'i' is the index of the last +leaf, the new one will be inserted at position 'i + 1'. Every time a +new leaf is inserted, the nodes that separate the new leaf from the root +of the tree are created or updated if they already exist, from bottom to top. +When a node has only one child (the left one), its value is the hash of that +node and the zero value of that level. Otherwise, the hash of the children +is calculated.
+Parameters
- leaf: any
The new leaf to be inserted in the tree.
+
Returns void
- leaf: any
update
- update(index, newLeaf): void
It updates a leaf in the tree. It's very similar to the IMT#insert function.
+Parameters
- index: number
The index of the leaf to be updated.
+ - newLeaf: any
The new leaf to be inserted.
+
Returns void
- index: number
verify
- verify
Proof(proof): boolean It verifies a IMTMerkleProof to confirm that a leaf indeed +belongs to a tree. Does not verify that the node belongs to this +tree in particular. Equivalent to
+IMT.verifyProof(proof, this._hash).Parameters
- proof: IMTMerkleProof
The Merkle tree proof.
+
Returns boolean
True if the leaf is part of the tree, and false otherwise.
+- proof: IMTMerkleProof
Static verify
- verify
Proof(proof, hash): boolean It verifies a IMTMerkleProof to confirm that a leaf indeed +belongs to a tree.
+Parameters
- proof: IMTMerkleProof
The Merkle tree proof.
+ - hash: IMTHashFunction
The hash function used to compute the tree nodes.
+
Returns boolean
True if the leaf is part of the tree, and false otherwise.
+- proof: IMTMerkleProof
Class LeanIMT<N>
The LeanIMT is an optimized binary version of the IMT. +This implementation exclusively supports binary trees, eliminates the use of +zeroes, and the tree's LeanIMT#depth is dynamic. When a node doesn't have the right child, +instead of using a zero hash as in the IMT, the node's value becomes that +of its left child. Furthermore, rather than utilizing a static tree depth, +it is updated based on the number of LeanIMT#leaves in the tree. This approach +results in the calculation of significantly fewer hashes, making the tree more efficient.
+Type Parameters
Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
Properties
Private Readonly _hash
The hash function used to compute the tree nodes.
+Private _nodes
The matrix where all the tree nodes are stored. The first index indicates +the level of the tree, while the second index represents the node's +position within that specific level. The last level will always contain +a list with a single element, which is the root. +Most of the attributes of this class are getters which can retrieve +their values from this matrix.
+Accessors
depth
- get depth(): number
The depth of the tree, which equals the number of levels - 1.
+Returns number
The depth of the tree.
+
leaves
- get leaves(): N[]
The leaves of the tree. They can be retrieved from the first +level of the tree using LeanIMT#_nodes. The returned +value is a copy of the array and not the original object.
+Returns N[]
The list of tree leaves.
+
root
- get root(): N
The root of the tree. This value doesn't need to be stored as +it is always the first and unique element of the last level of the tree. +Its value can be retrieved in LeanIMT#_nodes.
+Returns N
The root hash of the tree.
+
size
- get size(): number
The size of the tree, which the number of its leaves. +It's the length of the first level's list.
+Returns number
The number of leaves of the tree.
+
Methods
export
generate
- generate
Proof(index): LeanIMTMerkleProof<N> It generates a LeanIMTMerkleProof for a leaf of the tree. +That proof can be verified by this tree using the same hash function.
+Parameters
- index: number
The index of the leaf for which a Merkle proof will be generated.
+
Returns LeanIMTMerkleProof<N>
The Merkle proof of the leaf.
+- index: number
has
- has(leaf): boolean
It returns true if the leaf exists, and false otherwise
+Parameters
- leaf: N
A leaf of the tree.
+
Returns boolean
True if the tree has the leaf, and false otherwise.
+- leaf: N
import
- import(nodes): void
It imports an entire tree by initializing the nodes without calculating +any hashes. Note that it is crucial to ensure the integrity of the tree +before or after importing it. +The tree must be empty before importing.
+Parameters
- nodes: string
The stringified JSON of the tree.
+
Returns void
- nodes: string
index
- index
Of(leaf): number It returns the index of a leaf. If the leaf does not exist it returns -1.
+Parameters
- leaf: N
A leaf of the tree.
+
Returns number
The index of the leaf.
+- leaf: N
insert
- insert(leaf): void
The leaves are inserted incrementally. If 'i' is the index of the last +leaf, the new one will be inserted at position 'i + 1'. Every time a +new leaf is inserted, the nodes that separate the new leaf from the root +of the tree are created or updated if they already exist, from bottom to top. +When a node has only one child (the left one), its value takes on the value +of the child. Otherwise, the hash of the children is calculated.
+Parameters
- leaf: N
The new leaf to be inserted in the tree.
+
Returns void
- leaf: N
insert
- insert
Many(leaves): void This function is useful when you want to insert N leaves all at once. +It is more efficient than using the LeanIMT#insert method N times because it +significantly reduces the number of cases where a node has only one +child, which is a common occurrence in gradual insertion.
+Parameters
- leaves: N[]
The list of leaves to be inserted.
+
Returns void
- leaves: N[]
update
- update(index, newLeaf): void
It updates a leaf in the tree. It's very similar to the LeanIMT#insert function.
+Parameters
- index: number
The index of the leaf to be updated.
+ - newLeaf: N
The new leaf to be inserted.
+
Returns void
- index: number
verify
- verify
Proof(proof): boolean It verifies a LeanIMTMerkleProof to confirm that a leaf indeed +belongs to a tree. Does not verify that the node belongs to this +tree in particular. Equivalent to +
+LeanIMT.verifyProof(proof, this._hash).Parameters
- proof: LeanIMTMerkleProof<N>
The Merkle tree proof.
+
Returns boolean
True if the leaf is part of the tree, and false otherwise.
+- proof: LeanIMTMerkleProof<N>
Static verify
- verify
Proof<N>(proof, hash): boolean It verifies a LeanIMTMerkleProof to confirm that a leaf indeed +belongs to a tree.
+Type Parameters
Parameters
- proof: LeanIMTMerkleProof<N>
The Merkle tree proof.
+ - hash: LeanIMTHashFunction<N>
Returns boolean
True if the leaf is part of the tree, and false otherwise.
+- proof: LeanIMTMerkleProof<N>
Class SMT
SparseMerkleTree class provides all the functions to create a sparse Merkle tree
+and to take advantage of its features: SMT.add, SMT.get,
+SMT.update, SMT.delete, SMT.createProof,
+SMT.verifyProof.
+To better understand the code below it may be useful to describe the terminology used:
-
+
- nodes: every node in the tree is the hash of the two child nodes (
H(x, y));
+ - root node: the root node is the top hash and since it represents the whole data +structure it can be used to certify its integrity; +
- leaf nodes: every leaf node is the hash of a key/value pair and an additional
+value to mark the node as leaf node (
H(x, y, 1));
+ - entry: a tree entry is a key/value pair used to create the leaf nodes; +
- zero nodes: a zero node is an hash of zeros and in this implementation
H(0,0) = 0;
+ - siblings: the children of a parent node are siblings; +
- path: every entry key is a number < 2^256 that can be converted in a binary number, +and this binary number is the path used to place the entry in the tree (1 or 0 define the +child node to choose); +
- matching node: when an entry is not found and the path leads to another existing entry, +this entry is a matching entry and it has some of the first bits in common with the entry not found; +
- depth: the depth of a node is the length of the path to its root. +
Index
Constructors
Properties
Methods
Constructors
constructor
- new SMT(hash, bigNumbers?): SMT
Initializes the SparseMerkleTree attributes.
+Parameters
- hash: HashFunction
Hash function used to hash the child nodes.
+ - bigNumbers: boolean = false
BigInt type enabling.
+
Returns SMT
- hash: HashFunction
Properties
Private big
big
Private entry
Private hash
Private nodes
root
Private zero
Methods
add
Private add
Private calculate
Private check
- check
Parameter Type(parameter): void Checks the parameter type.
+Parameters
- parameter: Node
The parameter to check.
+
Returns void
- parameter: Node
create
- create
Proof(key): MerkleProof Creates a proof to prove the membership or the non-membership +of a tree entry.
+Parameters
- key: Node
A key of an existing or a non-existing entry.
+
Returns MerkleProof
The membership or the non-membership proof.
+- key: Node
delete
- delete(key): void
Deletes an entry in the tree. Also in this case all the hashes of +the nodes in the path of the entry are updated with a bottom-up approach.
+Parameters
- key: Node
The key of the entry.
+
Returns void
- key: Node
Private delete
get
Private is
- is
Leaf(node): boolean Checks if a node is a leaf node.
+Parameters
- node: Node
A node of the tree.
+
Returns boolean
True if the node is a leaf, false otherwise.
+- node: Node
Private retrieve
- retrieve
Entry(key): EntryResponse Searches for an entry in the tree. If the key passed as parameter exists in +the tree, the function returns the entry, otherwise it returns the entry +with only the key, and when there is another existing entry +in the same path it returns also this entry as 'matching entry'. +In any case the function returns the siblings of the path.
+Parameters
- key: Node
The key of the entry to search for.
+
Returns EntryResponse
The entry response.
+- key: Node
update
verify
- verify
Proof(merkleProof): boolean Verifies a membership or a non-membership proof.
+Parameters
- merkleProof: MerkleProof
The proof to verify.
+
Returns boolean
True if the proof is valid, false otherwise.
+- merkleProof: MerkleProof
Class F1Field
F1Field +Represents a finite field of order 'order' providing arithmetic operations under modulus. +This class includes operations such as addition, subtraction, multiplication, division, +and inversion, all performed modulo the field's order. It's designed to work with bigints, +supporting large numbers for cryptographic purposes and other applications requiring +modular arithmetic. +Note that the outputs of the functions will always be within the field if and only if +the input values are within the field. Devs need to make sure of that.
+Constructors
constructor
Properties
_half
_half: bigint
Half the order of the field, used for certain comparisons.
+_negone
_negone: bigint
The scalar value -1 in the field, represented positively.
+_order
_order: bigint
The order of the finite field (i.e., the modulus).
+one
one: bigint = ...
Represents the scalar value 1 in the field.
+zero
zero: bigint = ...
Represents the scalar value 0 in the field.
+Methods
add
div
e
eq
- eq(a, b): boolean
Checks if two bigint values are equal within the context of the field. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The first value to compare.
+ - b: bigint
The second value to compare.
+
Returns boolean
True if 'a' equals 'b', false otherwise.
+- a: bigint
geq
- geq(a, b): boolean
Compares two bigint values to determine if the first is greater than or equal to the second, +considering the field's modular context. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The first value to compare.
+ - b: bigint
The second value to compare.
+
Returns boolean
True if 'a' is greater than or equal to 'b', false otherwise.
+- a: bigint
inv
- inv(a): bigint
Computes the multiplicative inverse of a given value within the field. +This method uses the Extended Euclidean Algorithm to find the inverse, +ensuring the result is always a positive value less than the field's order. +If the input value is zero, which has no inverse, an error is thrown.
+Parameters
- a: bigint
The value for which to compute the inverse.
+
Returns bigint
The multiplicative inverse of 'a' modulo the field's order.
+Throws
if 'a' is zero.
+- a: bigint
is
lt
- lt(a, b): boolean
Compares two bigint values to determine if the first is less than the second, +taking into account the field's order for modular comparison. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The first value to compare.
+ - b: bigint
The second value to compare.
+
Returns boolean
True if 'a' is less than 'b', false otherwise.
+- a: bigint
mul
neg
- neg(a): bigint
Computes the negation of a bigint value within the field. +The result is the modular additive inverse that, when added to the original value, +yields zero in the field's modulus. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The value to negate.
+
Returns bigint
The negation of 'a' modulo the field's order.
+- a: bigint
pow
- pow(base, e): bigint
Raises a base to an exponent within the field, efficiently computing +scalar exponentiation using the square-and-multiply algorithm. +Supports both positive and negative exponents through the use of the
+invmethod for negatives.Parameters
- base: bigint
The base to be exponentiated.
+ - e: bigint
The exponent.
+
Returns bigint
The result of raising 'base' to the power 'e' modulo the field's order.
+- base: bigint
square
- square(a): bigint
Squares a bigint value within the field. +This is a specific case of multiplication where the value is multiplied by itself, +optimized for performance where applicable. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The value to square.
+
Returns bigint
The square of 'a' modulo the field's order.
+- a: bigint
sub
- sub(a, b): bigint
Subtracts one bigint from another under modulus. +It ensures the result is within the field if and only if the input values are within the field.
+Parameters
- a: bigint
The value from which to subtract.
+ - b: bigint
The value to be subtracted.
+
Returns bigint
The difference of 'a' and 'b' modulo the field's order.
+- a: bigint
\ No newline at end of file
diff --git a/enums/_zk_kit_utils.Proof.html b/enums/_zk_kit_utils.Proof.html
new file mode 100644
index 000000000..006bb242d
--- /dev/null
+++ b/enums/_zk_kit_utils.Proof.html
@@ -0,0 +1,8 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_baby_jubjub.addPoint.html b/functions/_zk_kit_baby_jubjub.addPoint.html
new file mode 100644
index 000000000..fbbc3f9c1
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.addPoint.html
@@ -0,0 +1,10 @@
+
Function addPoint
- add
Point(p1, p2): Point<bigint> Performs point addition on the Baby Jubjub elliptic curve, +calculating a third point from two given points. +Let P1 = (x1, y1) and P2 = (x2, y2) be two arbitrary points of the curve. +Then P1 + P2 = (x3, y3) is calculated in the following way: +x3 = (x1y2 + y1x2)/(1 + dx1x2y1y2) +y3 = (y1y2 - ax1x2)/(1 - dx1x2y1*y2)
+Returns Point<bigint>
Resultant third point on the curve.
+
Function inCurve
- in
Curve(p): boolean Determines if a given point lies on the Baby Jubjub elliptic curve by verifying the curve equation. +This function checks if the point satisfies the curve equation
+ax^2 + y^2 = 1 + dx^2y^2.Parameters
- p: Point
The point to check, represented as a pair of bigint values.
+
Returns boolean
True if the point is on the curve, otherwise false.
+- p: Point
Function mulPointEscalar
- mul
Point Escalar(base, e): Point<bigint> Performs a scalar multiplication by starting from the 'base' point and 'adding' +it to itself 'e' times.
+Parameters
- base: Point<bigint>
The base point used as a starting point.
+ - e: bigint
A secret number representing the private key.
+
Returns Point<bigint>
The resulting point representing the public key.
+- base: Point<bigint>
Function packPoint
- pack
Point(unpackedPoint): bigint Packs a point on the Baby Jubjub elliptic curve into a bigint. +This process involves converting the y-coordinate to a buffer and conditionally modifying the last byte +to encode the sign of the x-coordinate, following a specific compact representation format.
+Parameters
- unpackedPoint: Point<bigint>
The point to be packed, consisting of x and y coordinates.
+
Returns bigint
The packed representation of the point as a bigint.
+- unpackedPoint: Point<bigint>
Function unpackPoint
- unpack
Point(packedPoint): Point<bigint> | null Unpacks a bigint back into a point on the Baby Jubjub elliptic curve, reversing the packing process. +This involves interpreting the bigint as the y-coordinate and extracting the sign of the x-coordinate +from the encoded format. The function then calculates the x-coordinate using the curve equation.
+Parameters
- packedPoint: bigint
The packed point as a bigint.
+
Returns Point<bigint> | null
The unpacked point as a pair of bigint values, or null if the point is invalid.
+- packedPoint: bigint
Function derivePublicKey
- derive
Public Key(privateKey): Point<bigint> Derives a public key from a given private key using the +Jubjub elliptic curve. +This function utilizes the Baby Jubjub elliptic curve for cryptographic operations. +The private key should be securely stored and managed, and it should never be exposed +or transmitted in an unsecured manner.
+The private key must be an instance of Buffer, Uint8Array or a string. The input will be used to +generate entropy and there is no limit in size. +The string is used as a set of raw bytes (in UTF-8) and is typically used to pass passwords or secret messages. +If you want to pass a bigint, a number or a hexadecimal, be sure to convert them to one of the supported types first. +The 'conversions' module in @zk-kit/utils provides a set of functions that may be useful in case you need to convert types.
+Parameters
- privateKey: string | Uint8Array | Buffer
The private key used for generating the public key.
+
Returns Point<bigint>
The derived public key.
+- privateKey: string | Uint8Array | Buffer
Function deriveSecretScalar
- derive
Secret Scalar(privateKey): bigint Derives a secret scalar from a given EdDSA private key.
+This process involves hashing the private key with Blake1, pruning the resulting hash to retain the lower 32 bytes, +and converting it into a little-endian integer. The use of the secret scalar streamlines the public key generation +process by omitting steps 1, 2, and 3 as outlined in RFC 8032 section 5.1.5, enhancing circuit efficiency and simplicity. +This method is crucial for fixed-base scalar multiplication operations within the correspondent cryptographic circuit. +For detailed steps, see: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5. +For example usage in a circuit, see: https://github.com/semaphore-protocol/semaphore/blob/2c144fc9e55b30ad09474aeafa763c4115338409/packages/circuits/semaphore.circom#L21
+The private key must be an instance of Buffer, Uint8Array or a string. The input will be used to +generate entropy and there is no limit in size. +The string is used as a set of raw bytes (in UTF-8) and is typically used to pass passwords or secret messages. +If you want to pass a bigint, a number or a hexadecimal, be sure to convert them to one of the supported types first. +The 'conversions' module in @zk-kit/utils provides a set of functions that may be useful in case you need to convert types.
+Parameters
- privateKey: string | Uint8Array | Buffer
The EdDSA private key for generating the associated public key.
+
Returns bigint
The derived secret scalar to be used to calculate public key and optimized for circuit calculations.
+- privateKey: string | Uint8Array | Buffer
Function packPublicKey
- pack
Public Key(publicKey): bigint Converts a given public key into a packed (compressed) string format for efficient transmission and storage. +This method ensures the public key is valid and within the Baby Jubjub curve before packing.
+Parameters
- publicKey: Point
The public key to be packed.
+
Returns bigint
A string representation of the packed public key.
+- publicKey: Point
Function packSignature
- pack
Signature(signature): Buffer Packs an EdDSA signature into a buffer of 64 bytes for efficient storage. +Use unpackSignature to reverse the process without needing to know +the details of the format.
+The buffer contains the R8 point packed int 32 bytes (via +packSignature) followed by the S scalar. All encodings are +little-endian.
+Parameters
- signature: Signature
the signature to pack
+
Returns Buffer
a 64 byte buffer containing the packed signature
+- signature: Signature
Function signMessage
- sign
Message(privateKey, message): Signature<bigint> Signs a message using the provided private key, employing Poseidon hashing and +EdDSA with the Baby Jubjub elliptic curve.
+The private key must be an instance of Buffer, Uint8Array or a string. The input will be used to +generate entropy and there is no limit in size. +The string is used as a set of raw bytes (in UTF-8) and is typically used to pass passwords or secret messages. +If you want to pass a bigint, a number or a hexadecimal, be sure to convert them to one of the supported types first. +The 'conversions' module in @zk-kit/utils provides a set of functions that may be useful in case you need to convert types.
+Parameters
- privateKey: string | Uint8Array | Buffer
The private key used to sign the message.
+ - message: BigNumberish
The message to be signed.
+
Returns Signature<bigint>
The signature object, containing properties relevant to EdDSA signatures, such as 'R8' and 'S' values.
+- privateKey: string | Uint8Array | Buffer
Function unpackPublicKey
- unpack
Public Key(publicKey): Point<bigint> Unpacks a public key from its packed string representation back to its original point form on the Baby Jubjub curve. +This function checks for the validity of the input format before attempting to unpack.
+Parameters
- publicKey: BigNumberish
The packed public key as a bignumberish.
+
Returns Point<bigint>
The unpacked public key as a point.
+- publicKey: BigNumberish
Function unpackSignature
- unpack
Signature(packedSignature): Signature<bigint> Unpacks a signature produced by packSignature. See that function +for the details of the format.
+Parameters
- packedSignature: Buffer
the 64 byte buffer to unpack
+
Returns Signature<bigint>
a Signature with numbers in string form
+- packedSignature: Buffer
Function verifySignature
- verify
Signature(message, signature, publicKey): boolean Verifies an EdDSA signature using the Baby Jubjub elliptic curve and Poseidon hash function.
+Parameters
- message: BigNumberish
The original message that was be signed.
+ - signature: Signature
The EdDSA signature to be verified.
+ - publicKey: Point
The public key associated with the private key used to sign the message.
+
Returns boolean
Returns true if the signature is valid and corresponds to the message and public key, false otherwise.
+- message: BigNumberish
Function generate
- generate(privateKey, scope, snarkArtifacts?): Promise<EddsaProof>
Creates a zero-knowledge proof to prove that you have the pre-image of a Semaphore commitment, +without disclosing the actual preimage itself. +The use of a scope parameter along with a nullifier helps ensure the uniqueness +and non-reusability of the proofs, enhancing security in applications like +blockchain transactions or private data verification. +If, for example, this package were used with Semaphore to demonstrate possession +of a Semaphore identity of a group of voters, the scope could be the poll's ID.
+Parameters
- privateKey: string | Uint8Array | Buffer
The private key of the commitment.
+ - scope: Uint8Array | BigNumberish
A public value used to contextualize the cryptographic proof +and calculate the nullifier.
+ OptionalsnarkArtifacts: SnarkArtifactsThe Snark artifacts (wasm and zkey files) generated in +a trusted setup of the circuit are necessary to generate valid proofs
+
Returns Promise<EddsaProof>
The Poseidon zero-knowledge proof.
+- privateKey: string | Uint8Array | Buffer
Function verify
- verify(eddsaProof): Promise<boolean>
Verifies that a Eddsa proof is valid.
+Parameters
- eddsaProof: EddsaProof
The Eddsa zero-knowledge proof.
+
Returns Promise<boolean>
True if the proof is valid, false otherwise.
+- eddsaProof: EddsaProof
\ No newline at end of file
diff --git a/functions/_zk_kit_groth16.prove.html b/functions/_zk_kit_groth16.prove.html
new file mode 100644
index 000000000..ec1bb7a5b
--- /dev/null
+++ b/functions/_zk_kit_groth16.prove.html
@@ -0,0 +1,6 @@
+
Function prove
- prove(input, wasmFile, zkeyFile): Promise<{
proof: Groth16Proof;
publicSignals: PublicSignals;
}> Creates a Groth16 proof composed of public signals and zero-knowledge parameters.
+Parameters
- input: CircuitSignals
Input signals of the circuit.
+ - wasmFile: ZKArtifact
WASM file of the circuit.
+ - zkeyFile: ZKArtifact
ZKey file of the circuit.
+
Returns Promise<{
proof: Groth16Proof;
publicSignals: PublicSignals;
}>A proof containing public signals and zero-knowledge parameters.
+- input: CircuitSignals
Function verify
- verify(verificationKey, proof): Promise<boolean>
Verifies if a Groth16 proof is valid or not.
+Parameters
- verificationKey: any
The verification key used to verify the proof.
+ - proof: {
proof: Groth16Proof;
publicSignals: PublicSignals;
}The proof containing public signals and zero-knowledge parameters.
+proof: Groth16Proof
public
Signals: PublicSignals
Returns Promise<boolean>
True if the proof is valid, and false otherwise.
+- verificationKey: any
Function LazyTowerHashChainProofBuilder
- Lazy
Tower Hash Chain Proof Builder(H, W, hash?): {
add: ((item) => void);
build: ((idx) => LazyTowerHashChainProof);
indexOf: ((item) => number);
} LazyTowerHashChainProofBuilder is a TypeScript implementation of LazyTower to generate proofs of membership.
+Parameters
- H: number
Height of tower of the proving circuit. It can be less than the H in the contract.
+ - W: number
Width of tower.
+ - hash: ((a, b) => bigint) = defaultHash
A hash function which supports 2 input values.
+- (a, b): bigint
Parameters
- a: bigint
- b: bigint
Returns bigint
Returns {
add: ((item) => void);
build: ((idx) => LazyTowerHashChainProof);
indexOf: ((item) => number);
}add: ((item) => void)
- (item): void
Adds a new item in the LazyTower.
+Parameters
- item: bigint
Item to be added.
+
Returns void
- item: bigint
build: ((idx) => LazyTowerHashChainProof)
- (idx): LazyTowerHashChainProof
Builds a proof of membership.
+Parameters
- idx: number
Index of the proof's item.
+
Returns LazyTowerHashChainProof
Proof object.
+- idx: number
index
Of: ((item) => number) - (item): number
Returns the index of a item. If the item does not exist it returns -1.
+Parameters
- item: bigint
Added item.
+
Returns number
Index of the item.
+- item: bigint
- H: number
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.normalize.html b/functions/_zk_kit_poseidon_cipher.normalize.html
new file mode 100644
index 000000000..81345a484
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.normalize.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.poseidonDecrypt.html b/functions/_zk_kit_poseidon_cipher.poseidonDecrypt.html
new file mode 100644
index 000000000..bca61a7c8
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.poseidonDecrypt.html
@@ -0,0 +1,7 @@
+
Function poseidonDecrypt
- poseidon
Decrypt(ciphertext, key, nonce, length): PlainText<bigint> Decrypt some ciphertext using poseidon encryption
+Parameters
- ciphertext: CipherText<bigint>
the ciphertext to decrypt
+ - key: EncryptionKey<bigint>
the key to decrypt with
+ - nonce: bigint
the nonce used to encrypt
+ - length: number
the length of the plaintext
+
Returns PlainText<bigint>
the plaintext
+- ciphertext: CipherText<bigint>
Function poseidonDecryptWithoutCheck
- poseidon
Decrypt Without Check(ciphertext, key, nonce, length): PlainText<bigint> Decrypt some ciphertext using poseidon encryption
+Parameters
- ciphertext: CipherText<bigint>
the ciphertext to decrypt
+ - key: EncryptionKey<bigint>
the key to decrypt with
+ - nonce: bigint
the nonce used to encrypt
+ - length: number
the length of the plaintext
+
Returns PlainText<bigint>
the plaintext
+Dev
Do not throw if the plaintext is invalid
+- ciphertext: CipherText<bigint>
Function poseidonEncrypt
- poseidon
Encrypt(msg, key, nonce): CipherText<bigint> Encrypt some plaintext using poseidon encryption
+Parameters
- msg: PlainText<bigint>
the message to encrypt
+ - key: EncryptionKey<bigint>
the key to encrypt with
+ - nonce: bigint
the nonce to avoid replay attacks
+
Returns CipherText<bigint>
the ciphertext
+- msg: PlainText<bigint>
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.pow5.html b/functions/_zk_kit_poseidon_cipher.pow5.html
new file mode 100644
index 000000000..812e378dc
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.pow5.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.unstringifyBigInts.html b/functions/_zk_kit_poseidon_cipher.unstringifyBigInts.html
new file mode 100644
index 000000000..71fd43795
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.unstringifyBigInts.html
@@ -0,0 +1,5 @@
+
Function unstringifyBigInts
- unstringify
Big Ints(input): BigIntOutput Given an input containing string values, convert them +to bigint
+Parameters
- input: StringifiedInput
the input to convert
+
Returns BigIntOutput
the input with string values converted to bigint
+- input: StringifiedInput
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_proof.generate.html b/functions/_zk_kit_poseidon_proof.generate.html
new file mode 100644
index 000000000..1b4115c03
--- /dev/null
+++ b/functions/_zk_kit_poseidon_proof.generate.html
@@ -0,0 +1,14 @@
+
Function generate
- generate(preimages, scope, snarkArtifacts?): Promise<PoseidonProof>
Creates a zero-knowledge proof to prove that you have the preimages of a hash, +without disclosing the actual preimages themselves. +The use of a scope parameter helps ensure the uniqueness +and non-reusability of the proofs, enhancing security in applications like +blockchain transactions or private data verification. +If, for example, this package were used with Semaphore to demonstrate possession +of a Semaphore identity of a group of voters, the scope could be the poll's ID.
+Parameters
- preimages: BigNumberish[]
The preimages of the hash.
+ - scope: Uint8Array | BigNumberish
A public value used to contextualize the cryptographic proof +and calculate the nullifier.
+ OptionalsnarkArtifacts: SnarkArtifactsThe Snark artifacts (wasm and zkey files) generated in +a trusted setup of the circuit are necessary to generate valid proofs
+
Returns Promise<PoseidonProof>
The Poseidon zero-knowledge proof.
+- preimages: BigNumberish[]
Function verify
- verify(proof): Promise<boolean>
Verifies that a Poseidon proof is valid.
+Parameters
- proof: PoseidonProof
PoseidonProof
+
Returns Promise<boolean>
True if the proof is valid, false otherwise.
+- proof: PoseidonProof
\ No newline at end of file
diff --git a/functions/_zk_kit_smt.getFirstCommonElements.html b/functions/_zk_kit_smt.getFirstCommonElements.html
new file mode 100644
index 000000000..4073913fd
--- /dev/null
+++ b/functions/_zk_kit_smt.getFirstCommonElements.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_smt.getIndexOfLastNonZeroElement.html b/functions/_zk_kit_smt.getIndexOfLastNonZeroElement.html
new file mode 100644
index 000000000..14b65931b
--- /dev/null
+++ b/functions/_zk_kit_smt.getIndexOfLastNonZeroElement.html
@@ -0,0 +1,5 @@
+
Function getIndexOfLastNonZeroElement
\ No newline at end of file
diff --git a/functions/_zk_kit_smt.keyToPath.html b/functions/_zk_kit_smt.keyToPath.html
new file mode 100644
index 000000000..688cc75c5
--- /dev/null
+++ b/functions/_zk_kit_smt.keyToPath.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.beBigIntToBuffer.html b/functions/_zk_kit_utils.conversions.beBigIntToBuffer.html
new file mode 100644
index 000000000..ce011f1ae
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.beBigIntToBuffer.html
@@ -0,0 +1,9 @@
+
Function beBigIntToBuffer
- be
Big Int To Buffer(value, size?): Buffer Converts a bigint to a buffer and fills with zeros if a valid +size (i.e. number of bytes) is specified. If the size is not defined, +it gets the size from the given bigint. If the specified size is smaller than +the size of the bigint (i.e.
+minSize), an error is thrown. +It uses big-endian byte order.Parameters
- value: bigint
The bigint to convert.
+ Optionalsize: numberThe number of bytes of the buffer to return.
+
Returns Buffer
The buffer representation of the bigint.
+- value: bigint
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bigIntToBuffer.html b/functions/_zk_kit_utils.conversions.bigIntToBuffer.html
new file mode 100644
index 000000000..e74f7f677
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigIntToBuffer.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bigIntToHexadecimal.html b/functions/_zk_kit_utils.conversions.bigIntToHexadecimal.html
new file mode 100644
index 000000000..0f4e6282e
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigIntToHexadecimal.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bigNumberishToBigInt.html b/functions/_zk_kit_utils.conversions.bigNumberishToBigInt.html
new file mode 100644
index 000000000..e698efed1
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigNumberishToBigInt.html
@@ -0,0 +1,6 @@
+
Function bigNumberishToBigInt
- big
Numberish To Big Int(value): bigint Converts a BigNumberish type to a bigint. If the input is already a bigint, +the return value will be the bigint itself, otherwise it will be converted +to a bigint using big-endian byte order.
+Parameters
- value: BigNumberish
The BigNumberish value to convert.
+
Returns bigint
The bigint representation of the BigNumberish value.
+- value: BigNumberish
Function bigNumberishToBuffer
- big
Numberish To Buffer(value): Buffer Converts a BigNumberish type to a buffer. If the input is already a buffer, +the return value will be the buffer itself, otherwise it will be converted +to a buffer using big-endian byte order.
+Parameters
- value: BigNumberish
The BigNumberish value to convert.
+
Returns Buffer
The buffer representation of the BigNumberish value.
+- value: BigNumberish
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bufferToHexadecimal.html b/functions/_zk_kit_utils.conversions.bufferToHexadecimal.html
new file mode 100644
index 000000000..b0939ec38
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bufferToHexadecimal.html
@@ -0,0 +1,5 @@
+
Function bufferToHexadecimal
- buffer
To Hexadecimal(value): string Converts a buffer to a hexadecimal string. It accepts 'Buffer' or 'Uint8Array'. +The hexadecimal string will not start with '0x' or '0X'. It keeps the bytes in the same order.
+Parameters
- value: Uint8Array | Buffer
The buffer to convert.
+
Returns string
The converted hexadecimal string.
+- value: Uint8Array | Buffer
Function hexadecimalToBigInt
- hexadecimal
To Big Int(value): bigint Converts a hexadecimal string to a bigint. The input is interpreted as hexadecimal +with or without a '0x' prefix. It uses big-endian byte order.
+Parameters
- value: string
The hexadecimal string to convert.
+
Returns bigint
The bigint representation of the hexadecimal string.
+- value: string
Function hexadecimalToBuffer
- hexadecimal
To Buffer(value): Buffer Converts an hexadecimal string to a buffer. The hexadecimal string +should not start with '0x' or '0X'. It keeps the bytes in the same order.
+Parameters
- value: string
The hexadecimal string to convert.
+
Returns Buffer
The buffer representation of the hexadecimal string.
+- value: string
Function leBigIntToBuffer
- le
Big Int To Buffer(value, size?): Buffer Converts a bigint to a buffer and fills with zeros if a valid +size (i.e. number of bytes) is specified. If the size is not defined, +it gets the size from the given bigint. If the specified size is smaller than +the size of the bigint (i.e.
+minSize), an error is thrown. +It uses little-endian byte order.Parameters
- value: bigint
The bigint to convert.
+ Optionalsize: numberThe number of bytes of the buffer to return.
+
Returns Buffer
The buffer representation of the bigint in little-endian.
+- value: bigint
Function leBufferToBigInt
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireArray.html b/functions/_zk_kit_utils.errorHandlers.requireArray.html
new file mode 100644
index 000000000..031e59fac
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireArray.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireBigInt.html b/functions/_zk_kit_utils.errorHandlers.requireBigInt.html
new file mode 100644
index 000000000..b0462543c
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigInt.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireBigNumber.html b/functions/_zk_kit_utils.errorHandlers.requireBigNumber.html
new file mode 100644
index 000000000..e165155a4
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigNumber.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireBigNumberish.html b/functions/_zk_kit_utils.errorHandlers.requireBigNumberish.html
new file mode 100644
index 000000000..6ac852711
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigNumberish.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireBuffer.html b/functions/_zk_kit_utils.errorHandlers.requireBuffer.html
new file mode 100644
index 000000000..93953b0e9
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBuffer.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireDefined.html b/functions/_zk_kit_utils.errorHandlers.requireDefined.html
new file mode 100644
index 000000000..a293176d0
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireDefined.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireFunction.html b/functions/_zk_kit_utils.errorHandlers.requireFunction.html
new file mode 100644
index 000000000..cdda7c996
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireFunction.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireHexadecimal.html b/functions/_zk_kit_utils.errorHandlers.requireHexadecimal.html
new file mode 100644
index 000000000..133b84c1b
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireHexadecimal.html
@@ -0,0 +1,8 @@
+
Function requireHexadecimal
- require
Hexadecimal(parameterValue, parameterName, prefix?): void Parameters
- parameterValue: string
The parameter value.
+ - parameterName: string
The parameter name.
+ - prefix: boolean = true
A boolean to include or not a '0x' or '0X' prefix.
+
Returns void
Throws
Throws a type error if the parameter value is not a hexadecimal string. +If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more +hexadecimal digits (0-9, a-f, A-F), otherwise no prefix is expected. 'prefix' is optional and +if its value it is not explicitly defined it will be set to 'true' by default.
+- parameterValue: string
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireObject.html b/functions/_zk_kit_utils.errorHandlers.requireObject.html
new file mode 100644
index 000000000..3175ca6f9
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireObject.html
@@ -0,0 +1,5 @@
+
Function requireObject
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireStringifiedBigInt.html b/functions/_zk_kit_utils.errorHandlers.requireStringifiedBigInt.html
new file mode 100644
index 000000000..3bb084b97
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireStringifiedBigInt.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireTypes.html b/functions/_zk_kit_utils.errorHandlers.requireTypes.html
new file mode 100644
index 000000000..4dac84e92
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireTypes.html
@@ -0,0 +1,4 @@
+
Function requireTypes
- require
Types(parameterValue, parameterName, types): void Parameters
- parameterValue: any
The parameter value.
+ - parameterName: string
The parameter name.
+ - types: ("string" | "number" | "bigint" | "object" | "function" | "Array" | "Uint8Array" | "Buffer" | "stringified-bigint" | "hexadecimal" | "bignumber" | "bignumberish")[]
Returns void
Throws
Throws a type error if the parameter value type is not part of the list of types.
+- parameterValue: any
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.maybeGetEdDSASnarkArtifacts.html b/functions/_zk_kit_utils.maybeGetEdDSASnarkArtifacts.html
new file mode 100644
index 000000000..4004ebb84
--- /dev/null
+++ b/functions/_zk_kit_utils.maybeGetEdDSASnarkArtifacts.html
@@ -0,0 +1,5 @@
+
Function maybeGetEdDSASnarkArtifacts
- maybe
Get EdDSASnark Artifacts(): Promise<SnarkArtifacts> Downloads EdDSA snark artifacts (
+wasmandzkey) files if not already present in OS tmp folder.Returns Promise<SnarkArtifacts>
+Example
+{
wasm: "/tmm/@zk-kit/eddsa-artifacts@latest/eddsa.wasm",
zkey: "/tmp/@zk-kit/eddsa-artifacts@latest/eddsa.zkey"
} +
Function maybeGetPoseidonSnarkArtifacts
- maybe
Get Poseidon Snark Artifacts(numberOfInputs): Promise<SnarkArtifacts> Downloads Poseidon snark artifacts (
+wasmandzkey) files if not already present in OS tmp folder.Parameters
- numberOfInputs: number
The number of inputs to hash
+
Returns Promise<SnarkArtifacts>
+Example
+{
wasm: "/tmm/@zk-kit/poseidon-artifacts@latest/poseidon-2.wasm",
zkey: "/tmp/@zk-kit/poseidon-artifacts@latest/poseidon-2.zkey"
} +- numberOfInputs: number
Function maybeGetSemaphoreSnarkArtifacts
- maybe
Get Semaphore Snark Artifacts(treeDepth): Promise<SnarkArtifacts> Downloads Semaphore snark artifacts (
+wasmandzkey) files if not already present in OS tmp folder.Parameters
- treeDepth: number
The depth of the tree
+
Returns Promise<SnarkArtifacts>
+Example
+{
wasm: "/tmm/@zk-kit/semaphore-artifacts@latest/semaphore-3.wasm",
zkey: "/tmp/@zk-kit/semaphore-artifacts@latest/semaphore-3.zkey"
} +- treeDepth: number
Function packGroth16Proof
- pack
Groth16 Proof(proof): PackedGroth16Proof Packs a Snarkjs Groth16 proof into a single list usable as calldata in Solidity (public signals are not included).
+Parameters
- proof: Groth16Proof
The Groth16 proof generated with SnarkJS.
+
Returns PackedGroth16Proof
Solidity calldata.
+- proof: Groth16Proof
Function unpackGroth16Proof
- unpack
Groth16 Proof(proof): Groth16Proof Unpacks a PackedGroth16Proof Solidity calldata into its original form which is a SnarkJS Groth16 proof.
+Parameters
- proof: PackedGroth16Proof
Solidity calldata.
+
Returns Groth16Proof
The Groth16 proof compatible with SnarkJS.
+- proof: PackedGroth16Proof
Function bits
- bits(n): number[]
Converts a bigint scalar value into an array of bits, represented as numbers. +This function is particularly useful for examining the binary structure of bigints, +which can be necessary for bit manipulation and understanding the representation +of numbers at a lower level.
+Parameters
- n: bigint
The bigint scalar value to convert into bits.
+
Returns number[]
An array of numbers representing the bits of 'n', starting from the least significant bit.
+- n: bigint
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.isOdd.html b/functions/_zk_kit_utils.scalar.isOdd.html
new file mode 100644
index 000000000..8a5c19e89
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.isOdd.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.isZero.html b/functions/_zk_kit_utils.scalar.isZero.html
new file mode 100644
index 000000000..d304b5d23
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.isZero.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.mul.html b/functions/_zk_kit_utils.scalar.mul.html
new file mode 100644
index 000000000..3d4ec1f65
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.mul.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.shiftRight.html b/functions/_zk_kit_utils.scalar.shiftRight.html
new file mode 100644
index 000000000..fbeda8393
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.shiftRight.html
@@ -0,0 +1,7 @@
+
Function shiftRight
- shift
Right(a, n): bigint Performs a bitwise right shift on a bigint scalar value. +This operation is equivalent to dividing by 2^n, but it operates directly +on the binary representation, making it efficient for certain types of calculations.
+Parameters
- a: bigint
The bigint scalar value to shift.
+ - n: bigint
The number of bits to shift 'a' by.
+
Returns bigint
The result of shifting 'a' right by 'n' bits.
+- a: bigint
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isBigInt.html b/functions/_zk_kit_utils.typeChecks.isBigInt.html
new file mode 100644
index 000000000..1e01ef44c
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigInt.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isBigNumber.html b/functions/_zk_kit_utils.typeChecks.isBigNumber.html
new file mode 100644
index 000000000..dcfb7bea4
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigNumber.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isBigNumberish.html b/functions/_zk_kit_utils.typeChecks.isBigNumberish.html
new file mode 100644
index 000000000..03990f78d
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigNumberish.html
@@ -0,0 +1,7 @@
+
Function isBigNumberish
- is
Big Numberish(value): boolean Checks if the given value can be considered as BigNumberish. +A value is considered BigNumberish if it meets +any of the following conditions: it's a number, a bigint, a string +that can be converted to a bigint, a hexadecimal +string, or a Buffer object.
+Parameters
- value: any
The value to check.
+
Returns boolean
- value: any
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isDefined.html b/functions/_zk_kit_utils.typeChecks.isDefined.html
new file mode 100644
index 000000000..a088d9d66
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isDefined.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isFunction.html b/functions/_zk_kit_utils.typeChecks.isFunction.html
new file mode 100644
index 000000000..1ccc6c256
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isFunction.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isHexadecimal.html b/functions/_zk_kit_utils.typeChecks.isHexadecimal.html
new file mode 100644
index 000000000..0c28892d5
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isHexadecimal.html
@@ -0,0 +1,7 @@
+
Function isHexadecimal
- is
Hexadecimal(value, prefix?): boolean Checks if a string is a valid hexadecimal string representation. +If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more +hexadecimal digits (0-9, a-f, A-F), otherwise no prefix is expected. 'prefix' is optional and +if its value it is not explicitly defined it will be set to 'true' by default.
+Parameters
- value: any
The string to be tested.
+ - prefix: boolean = true
A boolean to include or not a '0x' or '0X' prefix.
+
Returns boolean
- value: any
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isObject.html b/functions/_zk_kit_utils.typeChecks.isObject.html
new file mode 100644
index 000000000..8e3888c47
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isObject.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isString.html b/functions/_zk_kit_utils.typeChecks.isString.html
new file mode 100644
index 000000000..006f5c33c
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isString.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isStringifiedBigInt.html b/functions/_zk_kit_utils.typeChecks.isStringifiedBigInt.html
new file mode 100644
index 000000000..6df7a9f58
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isStringifiedBigInt.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isSupportedType.html b/functions/_zk_kit_utils.typeChecks.isSupportedType.html
new file mode 100644
index 000000000..8567eb429
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isSupportedType.html
@@ -0,0 +1,4 @@
+
Function isSupportedType
- is
Supported Type(type): type is "string" | "number" | "bigint" | "object" | "function" | "Array" | "Uint8Array" | "Buffer" | "stringified-bigint" | "hexadecimal" | "bignumber" | "bignumberish" Returns true if the type is being supported by this utility +functions, false otherwise.
+Parameters
- type: string
The type to be checked.
+
Returns type is "string" | "number" | "bigint" | "object" | "function" | "Array" | "Uint8Array" | "Buffer" | "stringified-bigint" | "hexadecimal" | "bignumber" | "bignumberish"
- type: string
Function isType
- is
Type(value, type): boolean Returns true if the value type is the same as the type passed +as the second parameter, false otherwise.
+Parameters
- value: any
- type: "string" | "number" | "bigint" | "object" | "function" | "Array" | "Uint8Array" | "Buffer" | "stringified-bigint" | "hexadecimal" | "bignumber" | "bignumberish"
The expected type.
+
Returns boolean
\ No newline at end of file
diff --git a/hierarchy.html b/hierarchy.html
new file mode 100644
index 000000000..c3bf1ee8b
--- /dev/null
+++ b/hierarchy.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..ebc3e4d76
--- /dev/null
+++ b/index.html
@@ -0,0 +1,385 @@
+
zk-kit
+
+ 🧰 ZK-kit +
+A monorepo of reusable libraries for zero-knowledge technologies.
+ + +
+
+ 
+
+
+ 
+
+
+ 
&style=flat-square&logo=coveralls)
+
+
++ + 👥 Contributing + + | + + 🤝 Code of conduct + + | + + 🔎 Issues + + | + + 🗣️ Chat & Support + +
+| ZK-kit is a set of libraries (plugins, algorithms or utility functions) that can be reused in different projects and zero-knowledge protocols, making it easier for developers to access user-friendly, tested, and documented libraries for common tasks. | +
|---|
♚ Yarn workspaces: minimal monorepo package management (yarn, yarn build, yarn docs)
♛ Conventional Commits: human and machine readable meaning to commit messages (yarn commit)
♜ Jest: tests and test coverage for all libraries (yarn test:libraries)
♜ Mocha: tests for circuits and contracts (yarn test:circuits, yarn test:contracts)
♞ ESLint, Prettier: code quality and formatting (yarn prettier & yarn lint)
♝ Typedocs: documentation generator for TypeScript (yarn docs)
♟ Benny: simple benchmarking framework for JavaScript/TypeScript (yarn benchmarks)
♟ Github actions: software workflows for automatic testing, documentation deploy and code quality checks
📦 Packages
| Package | +Version | +Downloads | +Size | + +
|---|---|---|---|
| + + @zk-kit/circuits + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+ + |
| + + @zk-kit/eddsa-poseidon + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/poseidon-cipher + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/baby-jubjub + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/utils + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/imt + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/imt.sol + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+ + |
| + + @zk-kit/smt + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/poseidon-proof + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
| + + @zk-kit/eddsa-proof + + + (docs) + + | +
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
+
+
+ 
+
+ |
+
👥 Ways to contribute
-
+
- 🔧 Work on open issues +
- 📦 Suggest new packages +
- 🚀 Share ideas for new features +
- 🐛 Create a report if you find any bugs in the code +
🛠 Install
Clone this repository:
+git clone https://github.com/privacy-scaling-explorations/zk-kit.git
+and install the dependencies:
+cd zk-kit && yarn
+📜 Usage
Code quality and formatting
Run ESLint to analyze the code and catch bugs:
+yarn lint
+Run Prettier to check formatting rules:
+yarn prettier
+or to automatically format the code:
+yarn prettier:write
+Conventional commits
Semaphore uses conventional commits. A command line utility to commit using the correct syntax can be used by running:
+yarn commit
+It will also automatically check that the modified files comply with ESLint and Prettier rules.
+Testing
Test the code:
+yarn test
+Build
Build all the packages and compile contracts:
+yarn build
+A dist folder will be created inside each JavaScript package.
Documentation
Generate a documentation website for each package:
+yarn docs
+The output will be placed on the docs folder.
Releases
Bump a new version for your package with:
+yarn version:bump <package-name> <version>
# e.g. yarn version:bump utils 2.0.0
+It will create a commit and a git tag that you'll need to push on the main branch. A workflow will be triggered and will +publish your package on npm and release a new version on Github with its changelogs automatically.
+❓ FAQ
I have a library that could be reused in other projects. How can I integrate it on ZK-kit?
ZK-kit provides a set of pre-configured development tools. All you have to deal with is your own code, testing and documentation. To create a package follow these steps:
+-
+
- Fork this repository and clone it (or simply clone it directly if you are a collaborator), +
- Copy one of our current libraries and update the
README.mdandpackage.jsonfiles with your package name:
+
cd zk-kit
cp -r packages/smt packages/my-package
cd packages/my-package && rm -fr node_modules dist
grep -r -l "smt" . | xargs sed -i 's/smt/my-package/'
# Update the remaining description/usage sections, and write your code in the src & tests folders!
+-
+
- Create an issue for your package and open a PR. +
How can I create benchmarks for my library?
You can see some examples in the benchmarks folder. All you have to do is create a file that exports a function to run your benchmark in that folder, and add that function to the index.ts file. The yarn benchmarks command can be run with no parameters (it will run all the benchmarks), or you can specify the name of your benchmark file to run just that. When you run the command it will create a benchmarks/results folder with your results.
Interface CircuitSignals
Indexable
\ No newline at end of file
diff --git a/interfaces/_zk_kit_smt.EntryResponse.html b/interfaces/_zk_kit_smt.EntryResponse.html
new file mode 100644
index 000000000..e16f1763d
--- /dev/null
+++ b/interfaces/_zk_kit_smt.EntryResponse.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/interfaces/_zk_kit_smt.MerkleProof.html b/interfaces/_zk_kit_smt.MerkleProof.html
new file mode 100644
index 000000000..c94af3e79
--- /dev/null
+++ b/interfaces/_zk_kit_smt.MerkleProof.html
@@ -0,0 +1,6 @@
+
Interface MerkleProof
interface MerkleProof {
entry: Entry | Node[];
matchingEntry?: Entry | Node[];
membership: boolean;
root: Node;
siblings: Siblings;
}
entry: Entry | Node[];
matchingEntry?: Entry | Node[];
membership: boolean;
root: Node;
siblings: Siblings;
}
Hierarchy (view full)
- EntryResponse
- MerkleProof
Index
Properties
Properties
entry
Optional matching
membership
membership: boolean
root
siblings
\ No newline at end of file
diff --git a/modules/_zk_kit_baby_jubjub.html b/modules/_zk_kit_baby_jubjub.html
new file mode 100644
index 000000000..db629e322
--- /dev/null
+++ b/modules/_zk_kit_baby_jubjub.html
@@ -0,0 +1,78 @@
+
Module @zk-kit/baby-jubjub
+
+ Baby Jubjub +
+A JavaScript library for adding points to the Baby Jubjub curve.
+ + +
+
+ 
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+++[!WARNING]
+
This library has not been audited.
BabyJubJub is an elliptic curve optimized for secure, efficient cryptographic operations in constrained environments like blockchain and zero-knowledge proofs. It's designed for fast, privacy-preserving transactions, balancing cryptographic strength with performance, making it ideal for modern cryptographic solutions.
+References
-
+
- Barry WhiteHat, Marta Bellés, Jordi Baylina. ERC-2494: Baby Jubjub Elliptic Curve. 2020-01-29. https://eips.ethereum.org/EIPS/eip-2494. +
- Barry WhiteHat, Marta Bellés, Jordi Baylina. Baby Jubjub Elliptic Curve. https://docs.iden3.io/publications/pdfs/Baby-Jubjub.pdf +
+
🛠 Install
npm or yarn
Install the @zk-kit/baby-jubjub package and its peer dependencies with npm:
npm i @zk-kit/baby-jubjub
+or yarn:
+yarn add @zk-kit/baby-jubjub
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/baby-jubjub"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/baby-jubjub"></script>
+📜 Usage
import { packPoint, unpackPoint, Base8, mulPointEscalar, Point, addPoint } from "@zk-kit/baby-jubjub"
// Define two points on the BabyJubJub curve.
const p1: Point<bigint> = [BigInt(0), BigInt(1)] // Point at infinity (neutral element).
const p2: Point<bigint> = [BigInt(1), BigInt(0)] // Example point.
// Add the two points on the curve.
const p3 = addPoint(p1, p2)
// Add the result with Base8, another point on the curve, to get a new point.
const secretScalar = addPoint(Base8, p3)
// Multiply the base point by the x-coordinate of the secret scalar to get the public key.
const publicKey = mulPointEscalar(Base8, secretScalar[0])
// Pack the public key into a compressed format.
const packedPoint = packPoint(publicKey)
// Unpack the compressed public key back into its original form.
const unpackedPoint = unpackPoint(packedPoint)
if (unpackedPoint) {
console.log(publicKey[0] === unpackedPoint[0]) // true, checks if x-coordinates match
console.log(publicKey[1] === unpackedPoint[1]) // true, checks if y-coordinates match
}
+Index
Type Aliases
Point
+
Variables
Functions
Module @zk-kit/eddsa-poseidon
+
+ EdDSA Poseidon +
+A JavaScript EdDSA library for secure signing and verification using Poseidon and the Baby Jubjub elliptic curve.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+| This package offers a simplified JavaScript codebase essential for creating and validating digital signatures using EdDSA and Poseidon. It's built upon the Baby Jubjub elliptic curve, ensuring seamless integration with Circom and enhancing the developer experience. | +
|---|
++[!WARNING]
+
This library has not been audited.
-
+
- Super lightweight: ~33kB (minified) +
- Compatible with browsers and NodeJS +
- TS type support +
- Comprehensive code documentation +
- Full test coverage +
👾 Would you like to try it now? Explore it now on Ceditor!
+References
-
+
- Barry WhiteHat, Marta Bellés, Jordi Baylina. ERC-2494: Baby Jubjub Elliptic Curve. 2020-01-29. https://eips.ethereum.org/EIPS/eip-2494. +
- Lorenzo Grassi, Dmitry Khovratovich, Christian Rechberger, Arnab Roy, and Markus Schofnegger. POSEIDON: A New Hash Function for Zero-Knowledge Proof Systems. 2019. https://eprint.iacr.org/2019/458.pdf. +
🛠 Install
npm or yarn
Install the @zk-kit/eddsa-poseidon package and its peer dependencies with npm:
npm i @zk-kit/eddsa-poseidon
+or yarn:
+yarn add @zk-kit/eddsa-poseidon
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/eddsa-poseidon"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/eddsa-poseidon"></script>
+📜 Usage
import {
derivePublicKey,
signMessage,
verifySignature,
deriveSecretScalar,
packPublicKey,
unpackPublicKey
} from "@zk-kit/eddsa-poseidon"
// Your private key (secret).
const privateKey = "secret"
// The message you want to sign.
const message = "message"
// Derive a public key from the private key.
const publicKey = derivePublicKey(privateKey)
/*
[
17191193026255111087474416516591393721975640005415762645730433950079177536248n,
13751717961795090314625781035919035073474308127816403910435238282697898234143n
]
*/
console.log(publicKey)
// Sign the message.
const signature = signMessage(privateKey, message)
/*
{
R8: [
12949573675545142400102669657964360005184873166024880859462384824349649539693n,
18253636630408169174294927826710424418689461166073329946402765380454102840608n
],
S: 701803947557694254685424075312408605924670918868054593580245088593184746870n
}
*/
console.log(signature)
const response = verifySignature(message, signature, publicKey)
// true.
console.log(response)
// Use this value as the input for your Circom circuit.
const secretScalar = deriveSecretScalar(privateKey)
/*
6544992227624943856419766050818315045047569225455760139072025985369615672473
14277921624107172450683599157880963081763136590946434672207840996093731170206
*/
console.log(secretScalar)
// Pack the public key into a compressed format.
const packedPublicKey = packPublicKey(publicKey)
// 52359937820999550851358128406546520360380553803646081112576207882956925379784n
console.log(packedPublicKey)
// Unpack the compressed public key back into its original form.
const unpackedPublicKey = unpackPublicKey(packedPublicKey)
/*
[
17191193026255111087474416516591393721975640005415762645730433950079177536248n,
13751717961795090314625781035919035073474308127816403910435238282697898234143n
]
*/
console.log(unpackedPublicKey)
if (unpackedPublicKey) {
console.log(publicKey[0] === unpackedPublicKey[0]) // true
console.log(publicKey[1] === unpackedPublicKey[1]) // true
}
+Index
Classes
Type Aliases
Functions
Module @zk-kit/eddsa-proof
+
+ Eddsa proof +
+A library to generate and verify EdDSA proofs.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+This zero-knowledge library allows you to prove and verify that you have the private key of a Semaphore identity. It will be mainly used on-chain because you can get the same result off-chain using EdDSA signatures with the @semaphore-protocol/identity package. It facilitates the demonstration of having an EdDSA hash pre-image while keeping the pre-image value confidential. Additionally, it offers a mechanism to prevent the same proof from being reused. The circuit that forms the foundation of this library is accessible via this link. |
+
|---|
The Snark artifacts (.wasm and .zkey files) can be specified or not in the generate function parameters and can possibly be downloaded using the following URLs:
-
+
- https://zkkit.cedoor.dev/eddsa-proof/eddsa-proof.wasm +
- https://zkkit.cedoor.dev/eddsa-proof/eddsa-proof.zkey +
++[!WARNING]
+
The Snark artifacts currently used to generate zero-knowledge proofs are the result of an insecure trusted setup, and the library has not yet been audited. Therefore, it is advised not to use it in production.
🛠 Install
npm or yarn
Install the @zk-kit/eddsa-proof package:
npm i @zk-kit/eddsa-proof
+or yarn:
+yarn add @zk-kit/eddsa-proof
+📜 Usage
import { generate, verify } from "@zk-kit/eddsa-proof"
// Your private key (secret) associated with your commitment.
const privateKey = "secret"
// A public value used to contextualize the cryptographic proof and calculate the nullifier.
const scope = "scope"
// Generate the proof.
const fullProof = await generate(privateKey, scope)
/*
nb. commitment and scope are always the same - proof is variable.
{
commitment: '21756852044673293804725356853298692762259855200429755225624171532449447776732',
scope: '52191664570483756643537362991541193331102618014473399276861326740461293928448',
proof: [
'14987543977537638797613616391807211498102534775759297152458980015937921301475',
'3399335485250714998192957632691923175498432819155620830553382340417897595836',
'458847933923791518779258584891719351511628278818450523853640641455008133942',
'9130558865745328382423837376229933835283742789420937388990076948167771186665',
'2527867303822223913583586720705858457538165210401589969189198821632271648294',
'870032122185130505849909299495220614500026484724112145131565329210361970548',
'7499124546917660821334566902083675362480525785493429715971012094306224236446',
'4681140599918274218600441523225984097742730174371377925026448119492671129895'
]
}
*/
console.log(fullProof)
// If not specified, the Snark artifacts are downloaded automatically.
// You can specify them as follows.
// const fullProof = await generate(privateKey, scope, {
// wasm: "<your-path>/eddsa-proof.wasm",
// zkey: "<your-path>/eddsa-proof.zkey"
// })
// Verify the proof.
const response = await verify(fullProof)
// true.
console.log(response)
+📈 Benchmarks
Benchmarks were run on an Intel Core i7-1165G7, 16 GB RAM machine.
+| Generate proof | +Verify proof | +Constraints | +
|---|---|---|
258ms |
+15ms |
+1017 |
+
import { generate, verify } from "@zk-kit/eddsa-proof"
console.time("generate")
const proof = await generate("secret", "scope")
console.timeEnd("generate")
console.time("verify")
console.log(await verify(proof))
console.timeEnd("verify")
+Index
Type Aliases
Functions
Module @zk-kit/groth16
+
+ SnarkJS Groth16 +
+A snippet of SnarkJS code for verifying and generating Groth16 proofs only.
+ + +
+
+
+
+
+ 
+
+
+ 
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+++[!WARNING]
+
This package is no longer maintained as SnarkJS has integrated most of the above optimizations. Please, consider installing it instead.
This package contains SnarkJS functions for generating and verifying zero knowledge proofs with Groth16 specifically. In addition to the original code it also uses the cached bn128 curve if it already exists, making verification and generation of consecutive proofs faster. |
+
|---|
Some advantages of using this package instead of snarkjs directly are:
-
+
- It only includes code to verify and generate Groth16 proofs, making your final bundle lighter. +
- It doesn't call the ffjavascript
buildBn128function if abn128cached curve already exists, making verification and generation of consecutive proofs much faster (e.g. verification seems to be ~9 times faster after the first one).
+ - It includes TS types. +
- It provides an ESM bundle that is compatible with browsers. So there is no need to add any polyfill or additional configuration. +
References
-
+
- Jens Groth. On the Size of Pairing-Based Non-interactive Arguments. 2016-04-28. https://link.springer.com/chapter/10.1007/978-3-662-49896-5_11. +
+
🛠 Install
npm or yarn
Install the @zk-kit/groth16 package and its peer dependencies with npm:
npm i @zk-kit/groth16
+or yarn:
+yarn add @zk-kit/groth16
+📜 Usage
++[!WARNING]
+
You will need to provide your own circuits here in your specified path. Remember to define your circuit input and rename the files accordingly.
import { prove, verify, buildBn128 } from "@zk-kit/groth16"
// Build the BN128 curve for Groth16.
// https://github.com/iden3/ffjavascript/blob/master/src/wasm_field1.js
await buildBn128() // WasmField1
// Define your circuit input.
// const input = {
// input1: 1,
// input2: 2,
// inputN: "N"
// }
// Compute the proof.
const proof = await prove(input, "<YOUR-PATH>/circuit.zkey", "<YOUR-PATH>/circuit.wasm")
/*
{
proof: {
pi_a: [
'8259885706934172848141475422209230656096448508815982888010519325096632035723',
'3142099172052192611205205328157407975469005554072266974009053708782134081166',
'1'
],
pi_b: [ [Array], [Array], [Array] ],
pi_c: [
'13863804425308906943736719856399634046638544298517159271373916818387594277305',
'21340646707244019956779928177502771923632450548108204371058275686712196195969',
'1'
],
protocol: 'groth16',
curve: 'bn128'
},
publicSignals: [
'527758365153958423212195330785598453331596731388181860789801455413116800554',
'19104626566001952573667666924569656871967113105870778077087237826253896482830',
'122'
]
}
*/
console.log(proof)
// Verify the proof.
const response = await verify("<YOUR-PATH>/circuit_verification_key.json", proof)
// true or false.
console.log(response)
+Index
Interfaces
Type Aliases
Functions
Module @zk-kit/imt
+
+ Incremental Merkle Trees +
+Incremental Merkle tree implementations in TypeScript.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+An Incremental Merkle Tree is a dynamic data structure optimized for verifying data integrity in growing datasets. The updates are efficient since they modify only relevant nodes, avoiding the need to rebuild the entire tree with each change. This makes it ideal for real-time data verification contexts. You can learn more about the differences between MT and IMT here.
+++[!WARNING]
+
If you are looking for the first version of this package, please visit this link.
+
🛠 Install
npm or yarn
Install the @zk-kit/imt package with npm:
npm i @zk-kit/imt --save
+or yarn:
+yarn add @zk-kit/imt
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/imt"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/imt"></script>
+📜 Usage
IMT
In this implementation, the tree is built with a predetermined depth, utilizing a list of zeros (one for each level) to hash nodes lacking fully defined children. The tree's branching factor, or the number of children per node, can be customized via the arity parameter. For detailed insights into the implementation specifics, please refer to the technical documentation.
+import { IMT } from "@zk-kit/imt"
import { poseidon2 } from "poseidon-lite"
/**
* depth: number of nodes from the leaf to the tree's root node.
* zeroValue: default zero, can vary based on the specific use-case.
* arity: number of children per node (2 = Binary IMT, 5 = Quinary IMT).
*/
const depth = 16
const zeroValue = 0
const arity = 2
/**
* To create an instance of an IMT, you need to provide the hash function
* used to compute the tree nodes, as well as the depth, zeroValue, and arity of the tree.
*/
const tree = new IMT(poseidon2, depth, zeroValue, arity)
// You can also initialize a tree with a given list of leaves.
// const leaves = [1, 2, 3]
// new IMT(poseidon2, depth, zeroValue, arity, leaves)
// Insert (incrementally) a leaf with a value of 1.
tree.insert(1)
// Insert (incrementally) a leaf with a value of 3.
tree.insert(3)
// 6176938709541216276071057251289703345736952331798983957780950682673395007393n.
console.log(tree.root)
/*
[
0,
14744269619966411208579211824598458697587494354926760081771325075741142829156n,
7423237065226347324353380772367382631490014989348495481811164164159255474657n,
11286972368698509976183087595462810875513684078608517520839298933882497716792n,
3607627140608796879659380071776844901612302623152076817094415224584923813162n,
19712377064642672829441595136074946683621277828620209496774504837737984048981n,
20775607673010627194014556968476266066927294572720319469184847051418138353016n,
3396914609616007258851405644437304192397291162432396347162513310381425243293n,
21551820661461729022865262380882070649935529853313286572328683688269863701601n,
6573136701248752079028194407151022595060682063033565181951145966236778420039n,
12413880268183407374852357075976609371175688755676981206018884971008854919922n,
14271763308400718165336499097156975241954733520325982997864342600795471836726n,
20066985985293572387227381049700832219069292839614107140851619262827735677018n,
9394776414966240069580838672673694685292165040808226440647796406499139370960n,
11331146992410411304059858900317123658895005918277453009197229807340014528524n,
15819538789928229930262697811477882737253464456578333862691129291651619515538n
]
*/
console.log(tree.zeroes)
// 2
console.log(tree.arity)
// 16
console.log(tree.depth)
// [1, 3]
console.log(tree.leaves)
// Get the index of the leaf with value 3.
const idx = tree.indexOf(3)
// 1
console.log(idx)
// Update the value of the leaf at position 1 to 2.
tree.update(1, 2)
// [1, 2]
console.log(tree.leaves)
// Delete leaf at position 1.
tree.delete(1)
// [1, 0]
console.log(tree.leaves)
/**
* Compute a Merkle Inclusion Proof (proof of membership) for the leaf with index 1.
* The proof is only valid if the value 1 is found in a leaf of the tree.
*/
const proof = tree.createProof(1)
// true
console.log(tree.verifyProof(proof))
+Lean IMT
The LeanIMT is an optimized binary version of the IMT into binary-focused model, eliminating the need for zero values and allowing dynamic depth adjustment. Unlike the IMT, which uses a zero hash for incomplete nodes, the LeanIMT directly adopts the left child's value when a node lacks a right counterpart. The tree's depth dynamically adjusts to the count of leaves, enhancing efficiency by reducing the number of required hash calculations. To understand more about the LeanIMT, take a look at this visual explanation. For detailed insights into the implementation specifics, please refer to the technical documentation.
+import { LeanIMT } from "@zk-kit/imt"
import { poseidon2 } from "poseidon-lite"
/**
* Hash function used to compute the tree nodes.
*/
const hash = (a, b) => poseidon2([a, b])
// To create an instance of a LeanIMT, you must provide the hash function.
const tree = new LeanIMT(hash)
// You can also initialize a tree with a given list of leaves.
// const leaves = [1n, 2n, 3n]
// new LeanIMT(hash, leaves)
// LeanIMT is strictly typed. Default type for nodes is 'bigint',
// but you can set your own type.
// new LeanIMT<number>((a, b) => a + b)
// Insert (incrementally) a leaf with a value of 1.
tree.insert(1n)
// [1n]
console.log(tree.leaves)
// Insert (incrementally) a leaf with a value of 3.
tree.insert(3n)
// 21106761926285267690763443010820487107972411248208546226053195422384279971821n
console.log(tree.root)
// 1
console.log(tree.depth)
// 2
console.log(tree.size)
// [1n, 3n]
console.log(tree.leaves)
// Get the index of the leaf with value 3n.
const idx = tree.indexOf(3n)
// 1
console.log(idx)
// Check if the tree contains a leaf with value 4n.
const has = tree.has(4n)
// false
console.log(tree.has(4n))
// Update the value of the leaf at position 1 to 2n.
tree.update(1, 2n)
// [1n, 2n]
console.log(tree.leaves)
/**
* If you want to delete a leaf with LeanIMT you can use the update function with an
* arbitrary value to be used for the removed leaves.
*/
// Update the value of the leaf at position 1 to 0n (deletion).
tree.update(1, 0n)
// [1n, 0n]
console.log(tree.leaves)
/**
* Compute a Merkle Inclusion Proof (proof of membership) for the leaf with index 1.
* The proof is only valid if the value 1 is found in a leaf of the tree.
*/
const proof = tree.generateProof(1)
// true
console.log(tree.verifyProof(proof))
+Index
Classes
Type Aliases
Module @zk-kit/lazytower
+
+ LazyTower +
+LazyTower implementation in TypeScript.
+ + +
+
+
+
+
+ 
+
+
+ 
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
++
❗ WARNING
This library has not been audited.
+🛠 Install
npm or yarn
Install the @zk-kit/lazytower package with npm:
npm i @zk-kit/lazytower --save
+or yarn:
+yarn add @zk-kit/lazytower
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/lazytower/"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/lazytower/"></script>
+📜 Usage
import { LazyTowerHashChainProofBuilder } from "@zk-kit/lazytower"
import { poseidon } from "circomlibjs" // v0.0.8
const H = 10
const W = 4
const pb = LazyTowerHashChainProofBuilder(H, W, poseidon)
for (let i = BigInt(0); i < 150; i += BigInt(1)) {
pb.add(i)
}
const index = pb.indexOf(BigInt(42))
const proof = pb.build(index)
console.log(proof)
+Contacts
Developers
-
+
- e-mail : lcamel@gmail.com +
- github : @LCamel +
- website : https://www.facebook.com/LCamel +
Index
Type Aliases
Functions
Module @zk-kit/poseidon-cipher
+
+ Poseidon Cipher +
+Poseidon Hash function Encryption and Decryption implementation in TypeScript.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+This package implements encryption and decryption using the Poseidon hash function. This is a rewrite of the original implementation.
+References
-
+
- Dmitry Khovratovich. Encryption with Poseidon. 2019-12-26. https://drive.google.com/file/d/1EVrP3DzoGbmzkRmYnyEDcIQcXVU7GlOd/view. +
+
🛠 Install
npm or yarn
You can install @zk-kit/poseidon-cipher package with npm:
npm i @zk-kit/poseidon-cipher --save
+or yarn:
+yarn add @zk-kit/poseidon-cipher
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/poseidon-cipher"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/poseidon-cipher"></script>
+📜 Usage
import { poseidonEncrypt, poseidonDecrypt, poseidonDecryptWithoutCheck } from "@zk-kit/poseidon-cipher"
// BabyJubJub random value used as private key.
const privateKey = BigInt("10108149867830299554549347844489388280570828384194562713227904027271736843407")
console.log(privateKey)
// The BabyJubJub public key derived from the private key.
const publicKey = [
BigInt("15100511232447817691325643662379962541629809665246870882117771367990737816375"),
BigInt("16289853525630400225782441139722681929418024277641315637394850958390724375621")
]
/**
[
15100511232447817691325643662379962541629809665246870882117771367990737816375n,
16289853525630400225782441139722681929418024277641315637394850958390724375621n
]
*/
console.log(publicKey)
/**
* The Elliptic-Curve Diffie–Hellman (ECDH) shared key from the private and public key.
* Learn more at https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman.
*/
const encryptionKey = [
BigInt("18215233274609902892566361706948385597370728108990013889912246034099844508236"),
BigInt("14884395706232754242497822954958766875005771827082919466711779658153477561231")
]
/**
[
18215233274609902892566361706948385597370728108990013889912246034099844508236n,
14884395706232754242497822954958766875005771827082919466711779658153477561231n
]
*/
console.log(encryptionKey)
// The plaintext to be encrypted.
const plainText = [BigInt(0), BigInt(1)]
// The unique random value.
const nonce = BigInt(5)
// Compute the encryption.
const encrypted = poseidonEncrypt(plainText, encryptionKey, nonce)
/*
[
13027563531333274777964504528445510545245985419061604793949748860800093661040n,
21542829407417339379457427303368865281142518080970543920113508599380643597111n,
334052772696549592017166610161467257195783602071397160212931200489386609812n,
9075054520224362422769554641603717496449971372103870041485347221024944155182n
]
*/
console.log(encrypted)
// Compute the decryption.
const decrypted = poseidonDecrypt(encrypted, encryptionKey, nonce, plainText.length)
/*
[
0n,
1n
]
*/
console.log(decrypted)
// Compute the decryption without check.
const decryptedWithoutCheck = poseidonDecryptWithoutCheck(encrypted, encryptionKey, nonce, plainText.length)
/*
[
0n,
1n
]
*/
console.log(decryptedWithoutCheck)
+Index
Type Aliases
Variables
Functions
Module @zk-kit/poseidon-proof
+
+ Poseidon proof +
+A library to generate and verify Poseidon proofs.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+| This zero-knowledge library facilitates the demonstration of having a Poseidon hash pre-image while keeping the pre-image value confidential. Additionally, it offers a mechanism to prevent the same proof from being reused. The circuit that forms the foundation of this library is accessible via this link. | +
|---|
Originally developed for integration with Semaphore V4, this library also functions effectively as a standalone tool. Notable use cases in connection with Semaphore can be:
+-
+
- allowing a Semaphore user to prove that they possess the secret value associated with the identity commitment of their Semaphore identity, +
- unmasking the identity of zero-knowledge proofs earlier created using Semaphore. +
The Snark artifacts (.wasm and .zkey files) can be specified or not in the generate function parameters and can possibly be downloaded using the following URLs:
-
+
- https://zkkit.cedoor.dev/poseidon-proof/artifacts/${numberOfInputs}/poseidon-proof.wasm +
- https://zkkit.cedoor.dev/poseidon-proof/artifacts/${numberOfInputs}/poseidon-proof.zkey +
++[!WARNING]
+
The Snark artifacts currently used to generate zero-knowledge proofs are the result of an insecure trusted setup, and the library has not yet been audited. Therefore, it is advised not to use it in production.
🛠 Install
npm or yarn
Install the @zk-kit/poseidon-proof package:
npm i @zk-kit/poseidon-proof
+or yarn:
+yarn add @zk-kit/poseidon-proof
+📜 Usage
import { generate, verify } from "@zk-kit/poseidon-proof"
// A public value used to contextualize the cryptographic proof and calculate the nullifier.
const scope = "scope"
// The message (preimage) to prove (secret).
const messages = [1, 2]
// Generate the proof.
const fullProof = await generate(messages, scope)
/*
nb. scope, digest and nullifier are always the same - proof is variable.
{
scope: '2',
digest: '13713635907739611880977640264956372443229506353728466835599871320028961887800',
nullifier: '4995263610384888704435371233168916617325583088652670186865584118891394144999',
proof: [
'4344680442683455359115899095464919042642166233886432616638435348359080260980',
'20569010229031596977566212621532395450352277701036306316464269899598925981651',
'19318221594436336163085169568471746851468100277321435282188061183430353155289',
'13863222659316400652438453097923451250965656325472339120118358727133180331649',
'2718553541880998786976126630362604850217726344847462841516918030540821216281',
'11960084231774590415377471656397863783771599717615252119734899677642065267169',
'10666072962579546268534775428261696356732715643486735369393626224913301307278',
'4251217137130113647513155953595492143724626859298741948572817563032672674599'
]
}
*/
console.log(fullProof)
// If not specified, the Snark artifacts are downloaded automatically.
// You can specify them as follows.
// const fullProof = await generate(message, scope, {
// wasm: "<your-path>/poseidon-proof.wasm",
// zkey: "<your-path>/poseidon-proof.zkey"
// })
// Verify the proof.
const response = await verify(fullProof)
// true.
console.log(response)
// Eventually you may want to check the nullifier.
+📈 Benchmarks
Benchmarks were run on an Intel Core i7-1165G7, 16 GB RAM machine (with two inputs).
+| Generate proof | +Verify proof | +Constraints | +
|---|---|---|
170ms |
+12ms |
+214 |
+
import { generate, verify } from "@zk-kit/poseidon-proof"
console.time("generate")
const proof = await generate([1, 2], "scope")
console.timeEnd("generate")
console.time("verify")
console.log(await verify(proof))
console.timeEnd("verify")
+Index
Type Aliases
Functions
Module @zk-kit/smt
+
+ Sparse Merkle tree +
+Sparse Merkle tree implementation in TypeScript.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+A sparse Merkle tree is a data structure useful for storing a key/value map where every leaf node of the tree contains the cryptographic hash of a key/value pair and every non leaf node contains the concatenated hashes of its child nodes. Sparse Merkle trees provides a secure and efficient verification of large data sets and they are often used in peer-to-peer technologies. This implementation is an optimized version of the traditional sparse Merkle tree and it is based on the concepts expressed in the papers and resources below.
+References
-
+
- Rasmus Dahlberg, Tobias Pulls and Roel Peeters. Efficient Sparse Merkle Trees: Caching Strategies and Secure (Non-)Membership Proofs. Cryptology ePrint Archive: Report 2016/683, 2016. https://eprint.iacr.org/2016/683. +
- Faraz Haider. Compact sparse merkle trees. Cryptology ePrint Archive: Report 2018/955, 2018. https://eprint.iacr.org/2018/955. +
- Jordi Baylina and Marta Bellés. Sparse Merkle Trees. https://docs.iden3.io/publications/pdfs/Merkle-Tree.pdf. +
- Vitalik Buterin Fichter. Optimizing sparse Merkle trees. https://ethresear.ch/t/optimizing-sparse-merkle-trees/3751. +
+
Install
npm or yarn
You can install @zk-kit/smt package with npm:
npm i @zk-kit/smt --save
+or yarn:
+yarn add @zk-kit/smt
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/smt"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/smt"></script>
+📜 Usage
import { ChildNodes, SMT } from "@zk-kit/smt"
import sha256 from "crypto-js/sha256"
import { poseidon2 } from "poseidon-lite"
// Hexadecimal hashes.
const hash = (childNodes: ChildNodes) => sha256(childNodes.join("")).toString()
// Create the SMT with an Hexadecimal (SHA256) hash.
const tree = new SMT(hash)
// 0
console.log(tree.root)
// Big number hashes.
const hash2 = (childNodes: ChildNodes) => poseidon2(childNodes)
// Create the SMT with a BigNumber (Poseidon) hash.
const tree2 = new SMT(hash2, true)
// 0n
console.log(tree2.root)
// Add nodes to the SMT.
tree.add("2b", "44")
tree.add("16", "78")
tree.add("d", "e7")
tree.add("10", "141")
tree.add("20", "340")
// 31ee2a59741c9c32a32d8c7fafe461cca1ccaf5986c2d592586e3e6482a48645
console.log(tree.root)
// Get the value of the leaf.
const value = tree.get("16")
// 78
console.log(value)
// Update the value of the leaf.
tree.update("16", "79")
// 79
console.log(tree.get("16"))
// Delete the leaf.
tree.delete("16")
// undefined
console.log(tree.get("16"))
// Compute the proof of membership for the leaf.
const membershipProof = tree.createProof("2b")
// Compute the proof of membership for a previously deleted leaf.
const nonMembershipProof = tree.createProof("16") // This key has been deleted.
/*
{
entry: [ '2b', '44', '1' ],
matchingEntry: undefined,
siblings: [
'006a0ab15a212e0e0126b81e056b11576628b1ad80792403dbb3a90be2e71d64',
'f786ce5a843614d7da216d95c0087c1eb29244927feeeeeb658aa60cf124cd5e'
],
root: 'c3c023c84afc0a7bab1dbebcef5f7beaf3d6af4af98e8f481620dec052be7d0d',
membership: true
}
*/
console.log(membershipProof)
/*
{
entry: [ '16' ],
matchingEntry: undefined,
siblings: [
'960f23d9fbb44241be53efb7c4d69ac129bb1cb9482dcb6789d3cc7e6de2de2b',
'2a1aef839e68d1bdf43c1b3b1ed9ef16c27162e8a175898c9ac64a679b0fc825'
],
root: 'c3c023c84afc0a7bab1dbebcef5f7beaf3d6af4af98e8f481620dec052be7d0d',
membership: false
}
*/
console.log(nonMembershipProof)
// Verify the proofs.
console.log(tree.verifyProof(membershipProof)) // true
console.log(tree.verifyProof(nonMembershipProof)) // true
+Index
Classes
SMT
+
Interfaces
Type Aliases
Functions
Namespace conversions
Index
Functions
Namespace crypto
Index
Functions
Namespace errorHandlers
Index
Functions
Module @zk-kit/utils
+
+ Utils +
+Essential zero-knowledge utility library for JavaScript developers.
+ + +
+
+
+
+
+ 
+
+
+
+
+
++ + 🗣️ Chat & Support + + | + + 📘 Docs + +
+++[!WARNING]
+
This library has not been audited.
🛠 Install
npm or yarn
Install the @zk-kit/utils package and its peer dependencies with npm:
npm i @zk-kit/utils
+or yarn:
+yarn add @zk-kit/utils
+CDN
You can also load it using a script tag using unpkg:
<script src="https://unpkg.com/@zk-kit/utils"></script>
+or JSDelivr:
+<script src="https://cdn.jsdelivr.net/npm/@zk-kit/utils"></script>
+📜 Usage
// You can import modules from the main bundle.
import { errorHandlers, typeChecks } from "@zk-kit/utils"
// Or by using conditional exports.
import { requireNumber } from "@zk-kit/utils/error-handlers"
import { isNumber } from "@zk-kit/utils/type-checks"
+For more information on the functions provided by @zk-kit/utils, please refer to the documentation.
Index
References
Supported
Namespaces
Enumerations
Classes
F1
Interfaces
Type Aliases
Functions
References
Supported
Re-exports SupportedTypebe
Re-exports beBigIntToBufferbe
Re-exports beBufferToBigIntbig
Re-exports bigIntToBufferbig
Re-exports bigIntToHexadecimalbig
Re-exports bigNumberishToBigIntbig
Re-exports bigNumberishToBufferbuffer
Re-exports bufferToBigIntbuffer
Re-exports bufferToHexadecimalhexadecimal
Re-exports hexadecimalToBigInthexadecimal
Re-exports hexadecimalToBufferis
Re-exports isArrayis
Re-exports isBigIntis
Re-exports isBigNumberis
Re-exports isBigNumberishis
Re-exports isBufferis
Re-exports isDefinedis
Re-exports isFunctionis
Re-exports isHexadecimalis
Re-exports isNumberis
Re-exports isObjectis
Re-exports isStringis
Re-exports isStringifiedBigIntis
Re-exports isSupportedTypeis
Re-exports isTypeis
Re-exports isUint8Arrayle
Re-exports leBigIntToBufferle
Re-exports leBufferToBigIntpack
Re-exports packGroth16Proofrequire
Re-exports requireArrayrequire
Re-exports requireBigIntrequire
Re-exports requireBigNumberrequire
Re-exports requireBigNumberishrequire
Re-exports requireBufferrequire
Re-exports requireDefinedrequire
Re-exports requireFunctionrequire
Re-exports requireHexadecimalrequire
Re-exports requireNumberrequire
Re-exports requireObjectrequire
Re-exports requireStringrequire
Re-exports requireStringifiedBigIntrequire
Re-exports requireTypesrequire
Re-exports requireUint8Arraysupported
Re-exports supportedTypesunpack
Re-exports unpackGroth16ProofNamespace packing
Index
Functions
Namespace typeChecks
Index
Type Aliases
Variables
Functions
\ No newline at end of file
diff --git a/types/_zk_kit_eddsa_proof.EddsaProof.html b/types/_zk_kit_eddsa_proof.EddsaProof.html
new file mode 100644
index 000000000..be8b46e73
--- /dev/null
+++ b/types/_zk_kit_eddsa_proof.EddsaProof.html
@@ -0,0 +1 @@
+
Type alias EddsaProof
Type declaration
commitment: NumericString
proof: PackedGroth16Proof
scope: NumericString
Type alias NumericString
Numeric
Type alias PublicSignals
Type alias SignalValueType
Type alias ZKArtifact
ZKArtifact: string | Uint8Array
\ No newline at end of file
diff --git a/types/_zk_kit_imt.IMTMerkleProof.html b/types/_zk_kit_imt.IMTMerkleProof.html
new file mode 100644
index 000000000..e73e5ec35
--- /dev/null
+++ b/types/_zk_kit_imt.IMTMerkleProof.html
@@ -0,0 +1,9 @@
+
Type alias IMTMerkleProof
IMTMerkle
leaf: any;
leafIndex: number;
pathIndices: number[];
root: any;
siblings: any[];
}
leaf: any;
leafIndex: number;
pathIndices: number[];
root: any;
siblings: any[];
}
The Merkle Proof contains the necessary parameters to enable the +verifier to be certain that a leaf belongs to the tree. Given the value +of the leaf and its index, it is possible to traverse the tree by +recalculating the hashes up to the root and using the node siblings. +If the calculated root matches the root in the proof, then the leaf +belongs to the tree. It's important to note that the function used +to generate the proof and the one used to verify it must use the +same hash function.
+Type declaration
leaf: any
leaf
Index: number path
Indices: number[] root: any
siblings: any[]
Type alias IMTNode
IMTNode: any
It represents a node of the tree, which can be any value.
+
\ No newline at end of file
diff --git a/types/_zk_kit_imt.LeanIMTMerkleProof.html b/types/_zk_kit_imt.LeanIMTMerkleProof.html
new file mode 100644
index 000000000..fc4b54f0d
--- /dev/null
+++ b/types/_zk_kit_imt.LeanIMTMerkleProof.html
@@ -0,0 +1,9 @@
+
Type alias LeanIMTMerkleProof<N>
The Merkle Proof contains the necessary parameters to enable the +verifier to be certain that a leaf belongs to the tree. Given the value +of the leaf and its index, it is possible to traverse the tree by +recalculating the hashes up to the root and using the node siblings. +If the calculated root matches the root in the proof, then the leaf +belongs to the tree. It's important to note that the function used +to generate the proof and the one used to verify it must use the +same hash function.
+Type Parameters
Type alias LazyTowerHashChainProof
Lazy
childrens: bigint[][];
digestOfDigests: bigint;
item: bigint;
levelLengths: bigint;
rootLevel: bigint[];
rootLv: number;
topDownDigests: bigint[];
}
childrens: bigint[][];
digestOfDigests: bigint;
item: bigint;
levelLengths: bigint;
rootLevel: bigint[];
rootLv: number;
topDownDigests: bigint[];
}
Type declaration
childrens: bigint[][]
digest
Of Digests: bigint item: bigint
level
Lengths: bigint root
Level: bigint[] root
Lv: number top
Down Digests: bigint[]
Type alias BigIntOutput
Big
[key: string]: bigint;
} | null
[key: string]: bigint;
} | null
Type declaration
[key: string]: bigint
Type alias StringifiedInput
Stringified
[key: string]: StringifiedInput;
} | null
[key: string]: StringifiedInput;
} | null
Type declaration
[key: string]: StringifiedInput
Type alias PoseidonProof
Poseidon
digest: NumericString;
numberOfInputs: number;
proof: PackedGroth16Proof;
scope: NumericString;
}
digest: NumericString;
numberOfInputs: number;
proof: PackedGroth16Proof;
scope: NumericString;
}
Type declaration
digest: NumericString
number
Of Inputs: number proof: PackedGroth16Proof
scope: NumericString
Type alias ChildNodes
Type alias EntryMark
Type alias HashFunction
Type declaration
- (childNodes): Node
Parameters
- childNodes: ChildNodes
Returns Node
Type alias Key
Type alias Node
Node: string | bigint
Type alias Siblings
Type alias Value
Type alias BigNumber
Big
Type alias BigNumberish
Type alias PackedGroth16Proof
Packed
Type alias Version
Version: `${Digit}.${Digit}.${Digit}` | "latest"
Semantic version.
+Example
1.0.0
+Example
"latest"
+Type alias SupportedType
Variable Base8Const
Variable FrConst
Fr: default = ...
Variable orderConst
order: bigint = ...
Variable rConst
r: bigint = ...
Constants and curve parameters for BabyJubJub elliptic curve operations. +See: https://eips.ethereum.org/EIPS/eip-2494
+Variable subOrderConst
sub
Variable CConst
C: bigint[][] = ...
Variable MConst
M: bigint[][][] = ...
Variable supportedTypesConst Internal
supported
Represents a cryptographic entity capable of signing messages and verifying signatures +using the EdDSA scheme with Poseidon hash and the Baby Jubjub elliptic curve.
+