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.
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.
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.
+
PrivateReadonly_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.
It deletes a leaf from the tree. It does not remove the leaf from
+the data structure, but rather it sets the leaf to be deleted to the zero value.
+
Parameters
index: number
The index of the leaf to be deleted.
+
Returns void
indexOf
indexOf(leaf): number
It returns the index of a leaf. If the leaf does not exist it returns -1.
+
Parameters
leaf: any
A leaf of the tree.
+
Returns number
The index of the leaf.
+
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
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
verifyProof
verifyProof(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).
\ No newline at end of file
diff --git a/classes/_zk_kit_lean_imt.LeanIMT.html b/classes/_zk_kit_lean_imt.LeanIMT.html
new file mode 100644
index 000000000..3e92d5d6e
--- /dev/null
+++ b/classes/_zk_kit_lean_imt.LeanIMT.html
@@ -0,0 +1,105 @@
+LeanIMT | zk-kit
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.
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.
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.
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.
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
export(): string
It enables the conversion of the full tree structure into a JSON string,
+facilitating future imports of the tree. This approach is beneficial for
+large trees, as it saves time by storing hashes instead of recomputing them
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.
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.
Updates m leaves all at once.
+It is more efficient than using the LeanIMT#update method m times because it
+prevents updating middle nodes several times. This would happen when updating leaves
+with common ancestors. The naive approach of calling 'update' m times has complexity
+O(mlog(n)) (where n is the number of leaves of the tree), which ends up in
+O(nlog(n)) when m ~ n. With this new approach, this ends up being O(n) because every
+node is updated at most once and there are around 2*n nodes in the tree.
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).
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. If the map function is not defined, node
+values will be converted to bigints by default.
\ No newline at end of file
diff --git a/classes/_zk_kit_smt.SMT.html b/classes/_zk_kit_smt.SMT.html
new file mode 100644
index 000000000..6a62cc9af
--- /dev/null
+++ b/classes/_zk_kit_smt.SMT.html
@@ -0,0 +1,95 @@
+SMT | zk-kit
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.
Adds a new entry in the tree. It retrieves a matching entry
+or a zero node with a top-down approach and then it updates all the
+hashes of the nodes in the path of the new entry with a bottom-up approach.
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.
Updates a value of 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.
\ No newline at end of file
diff --git a/classes/_zk_kit_utils.F1Field.html b/classes/_zk_kit_utils.F1Field.html
new file mode 100644
index 000000000..46d4d7256
--- /dev/null
+++ b/classes/_zk_kit_utils.F1Field.html
@@ -0,0 +1,101 @@
+F1Field | zk-kit
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.
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
add(a, b): bigint
Adds two bigint values together 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 first value.
+
b: bigint
The second value.
+
Returns bigint
The sum of 'a' and 'b' modulo the field's order.
+
div
div(a, b): bigint
Divides one bigint by another within the field by multiplying the first value
+by the multiplicative inverse of the second.
+
Parameters
a: bigint
The dividend.
+
b: bigint
The divisor.
+
Returns bigint
The result of the division of 'a' by 'b' modulo the field's order.
+
e
e(res): bigint
Ensures a given result falls within the field by applying modular reduction.
+This method also handles negative inputs, correctly mapping them into the field.
+
Parameters
res: bigint
The result to be normalized to the field.
+
Returns bigint
The equivalent value within the field.
+
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.
+
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.
+
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.
+
isZero
isZero(a): boolean
Checks if a bigint value is zero within the context of the field.
+
Parameters
a: bigint
The value to check.
+
Returns boolean
True if 'a' is zero, false otherwise.
+
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.
+
mul
mul(a, b): bigint
Performs modular multiplication of two bigint values within the field.
+
Parameters
a: bigint
The first value.
+
b: bigint
The second value.
+
Returns bigint
The product of 'a' and 'b' modulo the field's order.
+
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.
+
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 inv method 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.
+
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.
+
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.
\ 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..4a23e7aac
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.addPoint.html
@@ -0,0 +1,10 @@
+addPoint | zk-kit
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)
\ No newline at end of file
diff --git a/functions/_zk_kit_baby_jubjub.inCurve.html b/functions/_zk_kit_baby_jubjub.inCurve.html
new file mode 100644
index 000000000..2ab8c8863
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.inCurve.html
@@ -0,0 +1,5 @@
+inCurve | zk-kit
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.
The point to check, represented as a pair of bigint values.
+
Returns boolean
True if the point is on the curve, otherwise false.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_baby_jubjub.mulPointEscalar.html b/functions/_zk_kit_baby_jubjub.mulPointEscalar.html
new file mode 100644
index 000000000..e890fbec4
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.mulPointEscalar.html
@@ -0,0 +1,6 @@
+mulPointEscalar | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_baby_jubjub.packPoint.html b/functions/_zk_kit_baby_jubjub.packPoint.html
new file mode 100644
index 000000000..a3ff1f495
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.packPoint.html
@@ -0,0 +1,6 @@
+packPoint | zk-kit
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.
The point to be packed, consisting of x and y coordinates.
+
Returns bigint
The packed representation of the point as a bigint.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_baby_jubjub.unpackPoint.html b/functions/_zk_kit_baby_jubjub.unpackPoint.html
new file mode 100644
index 000000000..dd59c8d1a
--- /dev/null
+++ b/functions/_zk_kit_baby_jubjub.unpackPoint.html
@@ -0,0 +1,6 @@
+unpackPoint | zk-kit
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.
The unpacked point as a pair of bigint values, or null if the point is invalid.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.derivePublicKey.html b/functions/_zk_kit_eddsa_poseidon.derivePublicKey.html
new file mode 100644
index 000000000..47c8e3e90
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.derivePublicKey.html
@@ -0,0 +1,13 @@
+derivePublicKey | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.deriveSecretScalar.html b/functions/_zk_kit_eddsa_poseidon.deriveSecretScalar.html
new file mode 100644
index 000000000..be21f49af
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.deriveSecretScalar.html
@@ -0,0 +1,13 @@
+deriveSecretScalar | zk-kit
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.
The private key used for generating the public key.
+
Returns bigint
The derived public key.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.packPublicKey.html b/functions/_zk_kit_eddsa_poseidon.packPublicKey.html
new file mode 100644
index 000000000..f135f093c
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.packPublicKey.html
@@ -0,0 +1,5 @@
+packPublicKey | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.packSignature.html b/functions/_zk_kit_eddsa_poseidon.packSignature.html
new file mode 100644
index 000000000..7595adb01
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.packSignature.html
@@ -0,0 +1,9 @@
+packSignature | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.signMessage.html b/functions/_zk_kit_eddsa_poseidon.signMessage.html
new file mode 100644
index 000000000..dede656c3
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.signMessage.html
@@ -0,0 +1,11 @@
+signMessage | zk-kit
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.
The signature object, containing properties relevant to EdDSA signatures, such as 'R8' and 'S' values.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.unpackPublicKey.html b/functions/_zk_kit_eddsa_poseidon.unpackPublicKey.html
new file mode 100644
index 000000000..778532537
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.unpackPublicKey.html
@@ -0,0 +1,5 @@
+unpackPublicKey | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.unpackSignature.html b/functions/_zk_kit_eddsa_poseidon.unpackSignature.html
new file mode 100644
index 000000000..db91dfc09
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.unpackSignature.html
@@ -0,0 +1,5 @@
+unpackSignature | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_eddsa_poseidon.verifySignature.html b/functions/_zk_kit_eddsa_poseidon.verifySignature.html
new file mode 100644
index 000000000..aec4bf0c9
--- /dev/null
+++ b/functions/_zk_kit_eddsa_poseidon.verifySignature.html
@@ -0,0 +1,6 @@
+verifySignature | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_lazytower.LazyTowerHashChainProofBuilder.html b/functions/_zk_kit_lazytower.LazyTowerHashChainProofBuilder.html
new file mode 100644
index 000000000..aa135c0e8
--- /dev/null
+++ b/functions/_zk_kit_lazytower.LazyTowerHashChainProofBuilder.html
@@ -0,0 +1,13 @@
+LazyTowerHashChainProofBuilder | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_logical_expressions.applyOperator.html b/functions/_zk_kit_logical_expressions.applyOperator.html
new file mode 100644
index 000000000..2464ad06a
--- /dev/null
+++ b/functions/_zk_kit_logical_expressions.applyOperator.html
@@ -0,0 +1,9 @@
+applyOperator | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_logical_expressions.evaluate.html b/functions/_zk_kit_logical_expressions.evaluate.html
new file mode 100644
index 000000000..85c5e24b9
--- /dev/null
+++ b/functions/_zk_kit_logical_expressions.evaluate.html
@@ -0,0 +1,18 @@
+evaluate | zk-kit
Function to evaluate a tokenized expression.
+This algorithm is an adaptation of the
+Shunting Yard
+algorithm to evaluate expressions with logical operators.
+
There is no need to verify the correctness of the logical expression
+before calling the evaluate function, as this will be checked during
+the evaluation. If the expression is incorrect, an error will be thrown automatically.
+
Example of correct logical expression: "true and false".
+
Example of incorrect logical expression: "true true and false".
+
Logical operators supported: and, or, not, xor.
+All other existing logical operators (nand, nor, xnor)
+can be generated using the supported logical operators.
+
Parameters
tokens: string[]
Tokens of the expression.
+The tokens can be boolean values, logical operators or parentheses.
+
Returns boolean
The boolean value after evaluating the expression.
+
Example
// Example usage: import { evaluate } from"@zk-kit/logical-expressions"
constexpression = ["true", "and", "false"]
constresult = evaluate(expression)
console.log(result) // Output: false
+
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_logical_expressions.precedence.html b/functions/_zk_kit_logical_expressions.precedence.html
new file mode 100644
index 000000000..20e6c617f
--- /dev/null
+++ b/functions/_zk_kit_logical_expressions.precedence.html
@@ -0,0 +1,9 @@
+precedence | zk-kit
Function to determine the precedence of operators.
+Unary operators have higher precedence.
+Binary operators have the same precedence.
+
Parameters
operator: string
Operator to check the precedence.
+
Returns number
The precedence of the operator or 0 if
+the operator is not supported
+
Example
// Example usage: import { precedence } from"@zk-kit/logical-expressions"
constresult = precedence("and")
console.log(result) // Output: 1
+
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_logical_expressions.tokenize.html b/functions/_zk_kit_logical_expressions.tokenize.html
new file mode 100644
index 000000000..f0829bbcb
--- /dev/null
+++ b/functions/_zk_kit_logical_expressions.tokenize.html
@@ -0,0 +1,6 @@
+tokenize | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.checkEqual.html b/functions/_zk_kit_poseidon_cipher.checkEqual.html
new file mode 100644
index 000000000..23c800056
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.checkEqual.html
@@ -0,0 +1,5 @@
+checkEqual | zk-kit
\ 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..ceded7f60
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.normalize.html
@@ -0,0 +1,5 @@
+normalize | zk-kit
Given a bigint a, returns a normalized value of a.
+
Parameters
a: bigint
the value to normalize
+
Returns bigint
the normalized value of a
+
Dev
r is 'r' is the alt_bn128 prime order, so we can use it to normalize values
+
Settings
Member Visibility
Theme
\ 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..ebdaaa4ed
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.poseidonDecrypt.html
@@ -0,0 +1,7 @@
+poseidonDecrypt | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.poseidonDecryptWithoutCheck.html b/functions/_zk_kit_poseidon_cipher.poseidonDecryptWithoutCheck.html
new file mode 100644
index 000000000..6961d6668
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.poseidonDecryptWithoutCheck.html
@@ -0,0 +1,8 @@
+poseidonDecryptWithoutCheck | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.poseidonEncrypt.html b/functions/_zk_kit_poseidon_cipher.poseidonEncrypt.html
new file mode 100644
index 000000000..a4e6cac27
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.poseidonEncrypt.html
@@ -0,0 +1,6 @@
+poseidonEncrypt | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.poseidonPerm.html b/functions/_zk_kit_poseidon_cipher.poseidonPerm.html
new file mode 100644
index 000000000..5009a7276
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.poseidonPerm.html
@@ -0,0 +1,4 @@
+poseidonPerm | zk-kit
Apply the Poseidon permutation to the given inputs
+
Parameters
inputs: bigint[]
the inputs to the permutation
+
Returns bigint[]
an array of bigint representing the output of the permutation
+
Settings
Member Visibility
Theme
\ 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..e1a5fd16a
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.pow5.html
@@ -0,0 +1,4 @@
+pow5 | zk-kit
\ 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..df989f24f
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.unstringifyBigInts.html
@@ -0,0 +1,5 @@
+unstringifyBigInts | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_cipher.validateNonce.html b/functions/_zk_kit_poseidon_cipher.validateNonce.html
new file mode 100644
index 000000000..769a90301
--- /dev/null
+++ b/functions/_zk_kit_poseidon_cipher.validateNonce.html
@@ -0,0 +1,3 @@
+validateNonce | zk-kit
Validate that the nonce is less than 2 ^ 128 (sqrt of the field size)
+
Parameters
nonce: bigint
the nonce to validate
+
Returns void
Settings
Member Visibility
Theme
\ 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..0add0f49f
--- /dev/null
+++ b/functions/_zk_kit_poseidon_proof.generate.html
@@ -0,0 +1,14 @@
+generate | zk-kit
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: BigNumberish | Uint8Array
A public value used to contextualize the cryptographic proof
+and calculate the nullifier.
+
OptionalsnarkArtifacts: SnarkArtifacts
The Snark artifacts (wasm and zkey files) generated in
+a trusted setup of the circuit are necessary to generate valid proofs
\ No newline at end of file
diff --git a/functions/_zk_kit_poseidon_proof.verify.html b/functions/_zk_kit_poseidon_proof.verify.html
new file mode 100644
index 000000000..114036505
--- /dev/null
+++ b/functions/_zk_kit_poseidon_proof.verify.html
@@ -0,0 +1,4 @@
+verify | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_smt.checkHex.html b/functions/_zk_kit_smt.checkHex.html
new file mode 100644
index 000000000..984a6a4ac
--- /dev/null
+++ b/functions/_zk_kit_smt.checkHex.html
@@ -0,0 +1,4 @@
+checkHex | zk-kit
True if the number is a hexadecimal, false otherwise.
+
Settings
Member Visibility
Theme
\ 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..d6a7a9db5
--- /dev/null
+++ b/functions/_zk_kit_smt.getFirstCommonElements.html
@@ -0,0 +1,5 @@
+getFirstCommonElements | zk-kit
\ 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..039f3f7c0
--- /dev/null
+++ b/functions/_zk_kit_smt.getIndexOfLastNonZeroElement.html
@@ -0,0 +1,5 @@
+getIndexOfLastNonZeroElement | zk-kit
Returns the index of the last non-zero element of an array.
+If there are only zero elements the function returns -1.
+
Parameters
array: any[]
An array of hexadecimal or big numbers.
+
Returns number
The index of the last non-zero element.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_smt.hexToBin.html b/functions/_zk_kit_smt.hexToBin.html
new file mode 100644
index 000000000..fc742324c
--- /dev/null
+++ b/functions/_zk_kit_smt.hexToBin.html
@@ -0,0 +1,4 @@
+hexToBin | zk-kit
\ 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..e018cf257
--- /dev/null
+++ b/functions/_zk_kit_smt.keyToPath.html
@@ -0,0 +1,5 @@
+keyToPath | zk-kit
Returns the binary representation of a key. For each key it is possible
+to obtain an array of 256 padded bits.
+
Parameters
key: string | bigint
The key of a tree entry.
+
Returns number[]
The relative array of bits.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.base64ToBuffer.html b/functions/_zk_kit_utils.conversions.base64ToBuffer.html
new file mode 100644
index 000000000..d641f5372
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.base64ToBuffer.html
@@ -0,0 +1,6 @@
+base64ToBuffer | zk-kit
Converts a base64 string to bytes (i.e. a buffer). This function does not check
+if the input value is a valid base64 string. If there are unsupported characters
+they will be ignored.
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.base64ToText.html b/functions/_zk_kit_utils.conversions.base64ToText.html
new file mode 100644
index 000000000..fe1d05adb
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.base64ToText.html
@@ -0,0 +1,6 @@
+base64ToText | zk-kit
Converts a base64 string to text (utf8). This function does not check
+if the input value is a valid base64 string. If there are unsupported characters
+they could be ignored and the result may be unexpected.
+
Parameters
value: string
The base64 string to convert.
+
Returns string
The converted text.
+
Settings
Member Visibility
Theme
\ 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..389aafe8e
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.beBigIntToBuffer.html
@@ -0,0 +1,9 @@
+beBigIntToBuffer | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.beBufferToBigInt.html b/functions/_zk_kit_utils.conversions.beBufferToBigInt.html
new file mode 100644
index 000000000..b3cbc7e3a
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.beBufferToBigInt.html
@@ -0,0 +1,5 @@
+beBufferToBigInt | zk-kit
The bigint representation of the buffer's contents.
+
Settings
Member Visibility
Theme
\ 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..93a2f39bf
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigIntToBuffer.html
@@ -0,0 +1,4 @@
+bigIntToBuffer | zk-kit
\ 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..539981e7e
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigIntToHexadecimal.html
@@ -0,0 +1,4 @@
+bigIntToHexadecimal | zk-kit
\ 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..b848daf75
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigNumberishToBigInt.html
@@ -0,0 +1,6 @@
+bigNumberishToBigInt | zk-kit
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.
The bigint representation of the BigNumberish value.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bigNumberishToBuffer.html b/functions/_zk_kit_utils.conversions.bigNumberishToBuffer.html
new file mode 100644
index 000000000..3b9201d5c
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bigNumberishToBuffer.html
@@ -0,0 +1,6 @@
+bigNumberishToBuffer | zk-kit
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.
The buffer representation of the BigNumberish value.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bufferToBase64.html b/functions/_zk_kit_utils.conversions.bufferToBase64.html
new file mode 100644
index 000000000..d629cbb36
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bufferToBase64.html
@@ -0,0 +1,4 @@
+bufferToBase64 | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.bufferToBigInt.html b/functions/_zk_kit_utils.conversions.bufferToBigInt.html
new file mode 100644
index 000000000..aea41cf29
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bufferToBigInt.html
@@ -0,0 +1,4 @@
+bufferToBigInt | zk-kit
The bigint representation of the buffer's contents.
+
Settings
Member Visibility
Theme
\ 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..c93f5a482
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.bufferToHexadecimal.html
@@ -0,0 +1,5 @@
+bufferToHexadecimal | zk-kit
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.
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.hexadecimalToBigInt.html b/functions/_zk_kit_utils.conversions.hexadecimalToBigInt.html
new file mode 100644
index 000000000..d783cf143
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.hexadecimalToBigInt.html
@@ -0,0 +1,5 @@
+hexadecimalToBigInt | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.hexadecimalToBuffer.html b/functions/_zk_kit_utils.conversions.hexadecimalToBuffer.html
new file mode 100644
index 000000000..a090a216a
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.hexadecimalToBuffer.html
@@ -0,0 +1,5 @@
+hexadecimalToBuffer | zk-kit
The buffer representation of the hexadecimal string.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.leBigIntToBuffer.html b/functions/_zk_kit_utils.conversions.leBigIntToBuffer.html
new file mode 100644
index 000000000..1a6b1e25f
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.leBigIntToBuffer.html
@@ -0,0 +1,9 @@
+leBigIntToBuffer | zk-kit
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.
The buffer representation of the bigint in little-endian.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.leBufferToBigInt.html b/functions/_zk_kit_utils.conversions.leBufferToBigInt.html
new file mode 100644
index 000000000..781027021
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.leBufferToBigInt.html
@@ -0,0 +1,5 @@
+leBufferToBigInt | zk-kit
The bigint representation of the buffer's contents in little-endian.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.conversions.textToBase64.html b/functions/_zk_kit_utils.conversions.textToBase64.html
new file mode 100644
index 000000000..c5f0256b0
--- /dev/null
+++ b/functions/_zk_kit_utils.conversions.textToBase64.html
@@ -0,0 +1,4 @@
+textToBase64 | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.crypto.getRandomValues.html b/functions/_zk_kit_utils.crypto.getRandomValues.html
new file mode 100644
index 000000000..86f1a2611
--- /dev/null
+++ b/functions/_zk_kit_utils.crypto.getRandomValues.html
@@ -0,0 +1,4 @@
+getRandomValues | zk-kit
Generates a random sequence of bytes securely using Node.js's crypto module.
+
Parameters
size: number
The number of bytes to generate.
+
Returns Uint8Array
A Uint8Array containing the generated random bytes.
+
Settings
Member Visibility
Theme
\ 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..85eca1db8
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireArray.html
@@ -0,0 +1,4 @@
+requireArray | zk-kit
Throws a type error if the parameter value is not an Array.
+
Settings
Member Visibility
Theme
\ 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..fa34597e4
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigInt.html
@@ -0,0 +1,4 @@
+requireBigInt | zk-kit
Throws a type error if the parameter value is not a bigint.
+
Settings
Member Visibility
Theme
\ 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..4229e1ddc
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigNumber.html
@@ -0,0 +1,4 @@
+requireBigNumber | zk-kit
Throws a type error if the parameter value is not a bignumber.
+
Settings
Member Visibility
Theme
\ 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..9b0437400
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBigNumberish.html
@@ -0,0 +1,4 @@
+requireBigNumberish | zk-kit
Throws a type error if the parameter value is not a bignumber-ish.
+
Settings
Member Visibility
Theme
\ 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..3e8c6f149
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireBuffer.html
@@ -0,0 +1,4 @@
+requireBuffer | zk-kit
Throws a type error if the parameter value is not a Buffer.
+
Settings
Member Visibility
Theme
\ 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..fd946b33e
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireDefined.html
@@ -0,0 +1,4 @@
+requireDefined | zk-kit
Throws a type error if the parameter value has not been defined.
+
Settings
Member Visibility
Theme
\ 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..f6e43fea4
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireFunction.html
@@ -0,0 +1,4 @@
+requireFunction | zk-kit
Throws a type error if the parameter value is not a function.
+
Settings
Member Visibility
Theme
\ 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..834d7240a
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireHexadecimal.html
@@ -0,0 +1,8 @@
+requireHexadecimal | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireNumber.html b/functions/_zk_kit_utils.errorHandlers.requireNumber.html
new file mode 100644
index 000000000..8875455af
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireNumber.html
@@ -0,0 +1,4 @@
+requireNumber | zk-kit
Throws a type error if the parameter value is not a number.
+
Settings
Member Visibility
Theme
\ 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..9e241c1ee
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireObject.html
@@ -0,0 +1,5 @@
+requireObject | zk-kit
Throws a type error if the parameter value is not an object.
+Please, note that arrays are also objects in JavaScript.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireString.html b/functions/_zk_kit_utils.errorHandlers.requireString.html
new file mode 100644
index 000000000..3f0e5ae49
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireString.html
@@ -0,0 +1,4 @@
+requireString | zk-kit
Throws a type error if the parameter value is not a string.
+
Settings
Member Visibility
Theme
\ 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..f56b38252
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireStringifiedBigInt.html
@@ -0,0 +1,4 @@
+requireStringifiedBigInt | zk-kit
Throws a type error if the parameter value is not a stringified bigint.
+
Settings
Member Visibility
Theme
\ 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..77fa12476
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireTypes.html
@@ -0,0 +1,4 @@
+requireTypes | zk-kit
Throws a type error if the parameter value type is not part of the list of types.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.errorHandlers.requireUint8Array.html b/functions/_zk_kit_utils.errorHandlers.requireUint8Array.html
new file mode 100644
index 000000000..faff1c38f
--- /dev/null
+++ b/functions/_zk_kit_utils.errorHandlers.requireUint8Array.html
@@ -0,0 +1,4 @@
+requireUint8Array | zk-kit
Throws a type error if the parameter value is not a Uint8Array.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.packing.packGroth16Proof.html b/functions/_zk_kit_utils.packing.packGroth16Proof.html
new file mode 100644
index 000000000..7892c5a2d
--- /dev/null
+++ b/functions/_zk_kit_utils.packing.packGroth16Proof.html
@@ -0,0 +1,4 @@
+packGroth16Proof | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.packing.unpackGroth16Proof.html b/functions/_zk_kit_utils.packing.unpackGroth16Proof.html
new file mode 100644
index 000000000..37187a82e
--- /dev/null
+++ b/functions/_zk_kit_utils.packing.unpackGroth16Proof.html
@@ -0,0 +1,4 @@
+unpackGroth16Proof | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.bits.html b/functions/_zk_kit_utils.scalar.bits.html
new file mode 100644
index 000000000..3116c693c
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.bits.html
@@ -0,0 +1,7 @@
+bits | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.scalar.gt.html b/functions/_zk_kit_utils.scalar.gt.html
new file mode 100644
index 000000000..23a890298
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.gt.html
@@ -0,0 +1,5 @@
+gt | zk-kit
Compares two bigint scalar values to determine if the first is greater than the second.
+
Parameters
a: bigint
The first bigint scalar value to compare.
+
b: bigint
The second bigint scalar value to compare.
+
Returns boolean
True if 'a' is greater than 'b', false otherwise.
+
Settings
Member Visibility
Theme
\ 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..3e52658e8
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.isOdd.html
@@ -0,0 +1,4 @@
+isOdd | zk-kit
\ 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..bbecf005b
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.isZero.html
@@ -0,0 +1,4 @@
+isZero | zk-kit
\ 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..a0637d7e9
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.mul.html
@@ -0,0 +1,5 @@
+mul | zk-kit
\ 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..45c320dea
--- /dev/null
+++ b/functions/_zk_kit_utils.scalar.shiftRight.html
@@ -0,0 +1,7 @@
+shiftRight | zk-kit
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.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isArray.html b/functions/_zk_kit_utils.typeChecks.isArray.html
new file mode 100644
index 000000000..362b93bae
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isArray.html
@@ -0,0 +1,3 @@
+isArray | zk-kit
Returns true if the value is an Array instance, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..48ed10a85
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigInt.html
@@ -0,0 +1,3 @@
+isBigInt | zk-kit
Returns true if the value is a bigint, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..17ce4ebd2
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigNumber.html
@@ -0,0 +1,5 @@
+isBigNumber | zk-kit
Checks if the given value can be considered as BigNumber.
+A value is considered a BigNumber if it is a bigint or a string
+that can be converted to a bigint (via Bigint(s)).
+
Parameters
value: any
The value to check.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..b4a501006
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBigNumberish.html
@@ -0,0 +1,7 @@
+isBigNumberish | zk-kit
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
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isBuffer.html b/functions/_zk_kit_utils.typeChecks.isBuffer.html
new file mode 100644
index 000000000..a89d57d30
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isBuffer.html
@@ -0,0 +1,3 @@
+isBuffer | zk-kit
Returns true if the value is a Buffer instance, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..387b7777b
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isDefined.html
@@ -0,0 +1,3 @@
+isDefined | zk-kit
Returns true if the value is defined, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..40a498420
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isFunction.html
@@ -0,0 +1,3 @@
+isFunction | zk-kit
Returns true if the value is a function, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..c51554598
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isHexadecimal.html
@@ -0,0 +1,7 @@
+isHexadecimal | zk-kit
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
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isNumber.html b/functions/_zk_kit_utils.typeChecks.isNumber.html
new file mode 100644
index 000000000..96f9cce9f
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isNumber.html
@@ -0,0 +1,3 @@
+isNumber | zk-kit
Returns true if the value is a number, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..c4496d5d4
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isObject.html
@@ -0,0 +1,4 @@
+isObject | zk-kit
Returns true if the value is an object, false otherwise.
+Please, note that arrays are also objects in JavaScript.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..f87348c06
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isString.html
@@ -0,0 +1,3 @@
+isString | zk-kit
Returns true if the value is a string, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..d75090b09
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isStringifiedBigInt.html
@@ -0,0 +1,3 @@
+isStringifiedBigInt | zk-kit
Checks if the given value is a string that represents a valid bigint.
+
Parameters
value: any
The value to be checked if it's a stringified bigint.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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..4534c870a
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isSupportedType.html
@@ -0,0 +1,4 @@
+isSupportedType | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isType.html b/functions/_zk_kit_utils.typeChecks.isType.html
new file mode 100644
index 000000000..fc390bf77
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isType.html
@@ -0,0 +1,4 @@
+isType | zk-kit
\ No newline at end of file
diff --git a/functions/_zk_kit_utils.typeChecks.isUint8Array.html b/functions/_zk_kit_utils.typeChecks.isUint8Array.html
new file mode 100644
index 000000000..bd50006a9
--- /dev/null
+++ b/functions/_zk_kit_utils.typeChecks.isUint8Array.html
@@ -0,0 +1,3 @@
+isUint8Array | zk-kit
Returns true if the value is a Uint8Array instance, false otherwise.
+
Parameters
value: any
The value to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ 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 @@
+zk-kit
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..0bac317f0
--- /dev/null
+++ b/index.html
@@ -0,0 +1,557 @@
+zk-kit
ZK-Kit is a set of libraries (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 code for common tasks. ZK-Kit provides different repositories for each language - this one contains JavaScript code only.
+
+
+
+
♚ 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) ♞ 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
yarnversion:bump <package-name> <version> # e.g. yarn version:bump utils 2.0.0
+
+
This step creates a commit and a git tag.
+
+
Push the changes to main:
+
+
gitpushoriginmain
+
+
+
Push the new git tag:
+
+
gitpushorigin <package-name>-<version> # e.g. git push origin utils-v2.0.0
+
+
After pushing the new git tag, a workflow will be triggered and will publish the package on npm and release a new version on Github with its changelogs automatically.
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.md and package.json files with your package name:
+
+
cdzk-kit cp-rpackages/smtpackages/my-package cdpackages/my-package && rm-frnode_modulesdist grep-r-l"smt". | xargssed-i's/smt/my-package/' # Update the remaining description/usage sections, and write your code in the src & tests folders!
+
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.
\ 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..541bd38fb
--- /dev/null
+++ b/interfaces/_zk_kit_smt.EntryResponse.html
@@ -0,0 +1,4 @@
+EntryResponse | zk-kit
\ 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..c51199ef7
--- /dev/null
+++ b/interfaces/_zk_kit_smt.MerkleProof.html
@@ -0,0 +1,6 @@
+MerkleProof | zk-kit
\ No newline at end of file
diff --git a/interfaces/_zk_kit_utils.Buffer.html b/interfaces/_zk_kit_utils.Buffer.html
new file mode 100644
index 000000000..6fee1a4b7
--- /dev/null
+++ b/interfaces/_zk_kit_utils.Buffer.html
@@ -0,0 +1,749 @@
+Buffer | zk-kit
Takes an integer value and returns the item at that index,
+allowing for positive and negative integers.
+Negative integers count back from the last item in the array.
Compares buf with target and returns a number indicating whether bufcomes before, after, or is the same as target in sort order.
+Comparison is based on the actual sequence of bytes in each Buffer.
+
+
0 is returned if target is the same as buf
+
1 is returned if target should come beforebuf when sorted.
+
-1 is returned if target should come afterbuf when sorted.
The optional targetStart, targetEnd, sourceStart, and sourceEnd arguments can be used to limit the comparison to specific ranges within target and buf respectively.
ERR_OUT_OF_RANGE is thrown if targetStart < 0, sourceStart < 0, targetEnd > target.byteLength, or sourceEnd > source.byteLength.
+
Parameters
target: Uint8Array
A Buffer or Uint8Array with which to compare buf.
+
OptionaltargetStart: number
The offset within target at which to begin comparison.
+
OptionaltargetEnd: number
The offset within target at which to end comparison (not inclusive).
+
OptionalsourceStart: number
The offset within buf at which to begin comparison.
+
OptionalsourceEnd: number
The offset within buf at which to end comparison (not inclusive).
+
Returns -1 | 0 | 1
Since
v0.11.13
+
copy
copy(target, targetStart?, sourceStart?, sourceEnd?): number
Copies data from a region of buf to a region in target, even if the targetmemory region overlaps with buf.
+
TypedArray.prototype.set() performs the same operation, and is available
+for all TypedArrays, including Node.js Buffers, although it takes
+different function arguments.
for (leti = 0; i < 26; i++) { // 97 is the decimal ASCII value for 'a'. buf1[i] = i + 97; }
// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`. buf1.copy(buf2, 8, 16, 20); // This is equivalent to: // buf2.set(buf1.subarray(16, 20), 8);
Determines whether all the members of an array satisfy the specified test.
+
Parameters
predicate: ((value, index, array) => unknown)
A function that accepts up to three arguments. The every method calls
+the predicate function for each element in the array until the predicate returns a value
+which is coercible to the Boolean value false, or until the end of the array.
+
(value, index, array): unknown
Parameters
value: number
index: number
array: Uint8Array
Returns unknown
OptionalthisArg: any
An object to which the this keyword can refer in the predicate function.
+If thisArg is omitted, undefined is used as the this value.
+
Returns boolean
fill
fill(value, offset?, end?, encoding?): this
Fills buf with the specified value. If the offset and end are not given,
+the entire buf will be filled:
value is coerced to a uint32 value if it is not a string, Buffer, or
+integer. If the resulting integer is greater than 255 (decimal), buf will be
+filled with value & 255.
+
If the final write of a fill() operation falls on a multi-byte character,
+then only the bytes of that character that fit into buf are written:
+
import { Buffer } from'node:buffer';
// Fill a `Buffer` with character that takes up two bytes in UTF-8.
If value contains invalid characters, it is truncated; if no valid
+fill data remains, an exception is thrown:
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(5);
console.log(buf.fill('a')); // Prints: <Buffer 61 61 61 61 61> console.log(buf.fill('aazz', 'hex')); // Prints: <Buffer aa aa aa aa aa> console.log(buf.fill('zz', 'hex')); // Throws an exception.
+
+
Parameters
value: string | number | Uint8Array
The value with which to fill buf. Empty value (string, Uint8Array, Buffer) is coerced to 0.
+
Optionaloffset: number
Number of bytes to skip before starting to fill buf.
+
Optionalend: number
Where to stop filling buf (not inclusive).
+
Optionalencoding: BufferEncoding
The encoding for value if value is a string.
+
Returns this
A reference to buf.
+
Since
v0.5.0
+
filter
filter(predicate, thisArg?): Uint8Array
Returns the elements of an array that meet the condition specified in a callback function.
+
Parameters
predicate: ((value, index, array) => any)
A function that accepts up to three arguments. The filter method calls
+the predicate function one time for each element in the array.
+
(value, index, array): any
Parameters
value: number
index: number
array: Uint8Array
Returns any
OptionalthisArg: any
An object to which the this keyword can refer in the predicate function.
+If thisArg is omitted, undefined is used as the this value.
+
Returns Uint8Array
find
find(predicate, thisArg?): undefined | number
Returns the value of the first element in the array where predicate is true, and undefined
+otherwise.
+
Parameters
predicate: ((value, index, obj) => boolean)
find calls predicate once for each element of the array, in ascending
+order, until it finds one where predicate returns true. If such an element is found, find
+immediately returns that element value. Otherwise, find returns undefined.
+
(value, index, obj): boolean
Parameters
value: number
index: number
obj: Uint8Array
Returns boolean
OptionalthisArg: any
If provided, it will be used as the this value for each invocation of
+predicate. If it is not provided, undefined is used instead.
+
Returns undefined | number
findIndex
findIndex(predicate, thisArg?): number
Returns the index of the first element in the array where predicate is true, and -1
+otherwise.
+
Parameters
predicate: ((value, index, obj) => boolean)
find calls predicate once for each element of the array, in ascending
+order, until it finds one where predicate returns true. If such an element is found,
+findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+
(value, index, obj): boolean
Parameters
value: number
index: number
obj: Uint8Array
Returns boolean
OptionalthisArg: any
If provided, it will be used as the this value for each invocation of
+predicate. If it is not provided, undefined is used instead.
+
Returns number
forEach
forEach(callbackfn, thisArg?): void
Performs the specified action for each element in an array.
+
Parameters
callbackfn: ((value, index, array) => void)
A function that accepts up to three arguments. forEach calls the
+callbackfn function one time for each element in the array.
+
(value, index, array): void
Parameters
value: number
index: number
array: Uint8Array
Returns void
OptionalthisArg: any
An object to which the this keyword can refer in the callbackfn function.
+If thisArg is omitted, undefined is used as the this value.
If value is not a string, number, or Buffer, this method will throw a TypeError. If value is a number, it will be coerced to a valid byte value,
+an integer between 0 and 255.
+
If byteOffset is not a number, it will be coerced to a number. If the result
+of coercion is NaN or 0, then the entire buffer will be searched. This
+behavior matches String.prototype.indexOf().
+
import { Buffer } from'node:buffer';
constb = Buffer.from('abcdef');
// Passing a value that's a number, but not a valid byte. // Prints: 2, equivalent to searching for 99 or 'c'. console.log(b.indexOf(99.9)); console.log(b.indexOf(256 + 99));
// Passing a byteOffset that coerces to NaN or 0. // Prints: 1, searching the whole buffer. console.log(b.indexOf('b', undefined)); console.log(b.indexOf('b', {})); console.log(b.indexOf('b', null)); console.log(b.indexOf('b', []));
+
+
If value is an empty string or empty Buffer and byteOffset is less
+than buf.length, byteOffset will be returned. If value is empty andbyteOffset is at least buf.length, buf.length will be returned.
+
Parameters
value: string | number | Uint8Array
What to search for.
+
OptionalbyteOffset: number
Where to begin searching in buf. If negative, then offset is calculated from the end of buf.
+
Optionalencoding: BufferEncoding
If value is a string, this is the encoding used to determine the binary representation of the string that will be searched for in buf.
+
Returns number
The index of the first occurrence of value in buf, or -1 if buf does not contain value.
+
Since
v1.5.0
+
join
join(separator?): string
Adds all the elements of an array separated by the specified separator string.
+
Parameters
Optionalseparator: string
A string used to separate one element of an array from the next in the
+resulting String. If omitted, the array elements are separated with a comma.
+
Returns string
keys
keys(): ArrayIterator<number>
Returns an list of keys in the array
+
Returns ArrayIterator<number>
lastIndexOf
lastIndexOf(value, byteOffset?, encoding?): number
Identical to buf.indexOf(), except the last occurrence of value is found
+rather than the first occurrence.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.from('this buffer is a buffer');
console.log(buf.lastIndexOf('this')); // Prints: 0 console.log(buf.lastIndexOf('buffer')); // Prints: 17 console.log(buf.lastIndexOf(Buffer.from('buffer'))); // Prints: 17 console.log(buf.lastIndexOf(97)); // Prints: 15 (97 is the decimal ASCII value for 'a') console.log(buf.lastIndexOf(Buffer.from('yolo'))); // Prints: -1 console.log(buf.lastIndexOf('buffer', 5)); // Prints: 5 console.log(buf.lastIndexOf('buffer', 4)); // Prints: -1
If value is not a string, number, or Buffer, this method will throw a TypeError. If value is a number, it will be coerced to a valid byte value,
+an integer between 0 and 255.
+
If byteOffset is not a number, it will be coerced to a number. Any arguments
+that coerce to NaN, like {} or undefined, will search the whole buffer.
+This behavior matches String.prototype.lastIndexOf().
+
import { Buffer } from'node:buffer';
constb = Buffer.from('abcdef');
// Passing a value that's a number, but not a valid byte. // Prints: 2, equivalent to searching for 99 or 'c'. console.log(b.lastIndexOf(99.9)); console.log(b.lastIndexOf(256 + 99));
// Passing a byteOffset that coerces to NaN. // Prints: 1, searching the whole buffer. console.log(b.lastIndexOf('b', undefined)); console.log(b.lastIndexOf('b', {}));
// Passing a byteOffset that coerces to 0. // Prints: -1, equivalent to passing 0. console.log(b.lastIndexOf('b', null)); console.log(b.lastIndexOf('b', []));
+
+
If value is an empty string or empty Buffer, byteOffset will be returned.
+
Parameters
value: string | number | Uint8Array
What to search for.
+
OptionalbyteOffset: number
Where to begin searching in buf. If negative, then offset is calculated from the end of buf.
+
Optionalencoding: BufferEncoding
If value is a string, this is the encoding used to determine the binary representation of the string that will be searched for in buf.
+
Returns number
The index of the last occurrence of value in buf, or -1 if buf does not contain value.
+
Since
v6.0.0
+
map
map(callbackfn, thisArg?): Uint8Array
Calls a defined callback function on each element of an array, and returns an array that
+contains the results.
+
Parameters
callbackfn: ((value, index, array) => number)
A function that accepts up to three arguments. The map method calls the
+callbackfn function one time for each element in the array.
+
(value, index, array): number
Parameters
value: number
index: number
array: Uint8Array
Returns number
OptionalthisArg: any
An object to which the this keyword can refer in the callbackfn function.
+If thisArg is omitted, undefined is used as the this value.
+
Returns Uint8Array
readBigInt64BE
readBigInt64BE(offset?): bigint
Reads a signed, big-endian 64-bit integer from buf at the specified offset.
+
Integers read from a Buffer are interpreted as two's complement signed
+values.
+
Parameters
Optionaloffset: number
Number of bytes to skip before starting to read. Must satisfy: 0 <= offset <= buf.length - 8.
+
Returns bigint
Since
v12.0.0, v10.20.0
+
readBigInt64LE
readBigInt64LE(offset?): bigint
Reads a signed, little-endian 64-bit integer from buf at the specifiedoffset.
+
Integers read from a Buffer are interpreted as two's complement signed
+values.
+
Parameters
Optionaloffset: number
Number of bytes to skip before starting to read. Must satisfy: 0 <= offset <= buf.length - 8.
+
Returns bigint
Since
v12.0.0, v10.20.0
+
readBigUInt64BE
readBigUInt64BE(offset?): bigint
Reads an unsigned, big-endian 64-bit integer from buf at the specifiedoffset.
+
This function is also available under the readBigUint64BE alias.
Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - 1.
+
Returns number
Since
v0.5.0
+
readIntBE
readIntBE(offset, byteLength): number
Reads byteLength number of bytes from buf at the specified offset and interprets the result as a big-endian, two's complement signed value
+supporting up to 48 bits of accuracy.
Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to read. Must satisfy 0 < byteLength <= 6.
+
Returns number
Since
v0.11.15
+
readIntLE
readIntLE(offset, byteLength): number
Reads byteLength number of bytes from buf at the specified offset and interprets the result as a little-endian, two's complement signed value
+supporting up to 48 bits of accuracy.
Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - 1.
+
Returns number
Since
v0.5.0
+
readUIntBE
readUIntBE(offset, byteLength): number
Reads byteLength number of bytes from buf at the specified offset and interprets the result as an unsigned big-endian integer supporting
+up to 48 bits of accuracy.
+
This function is also available under the readUintBE alias.
Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to read. Must satisfy 0 < byteLength <= 6.
+
Returns number
Since
v0.11.15
+
readUIntLE
readUIntLE(offset, byteLength): number
Reads byteLength number of bytes from buf at the specified offset and interprets the result as an unsigned, little-endian integer supporting
+up to 48 bits of accuracy.
+
This function is also available under the readUintLE alias.
Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to read. Must satisfy 0 < byteLength <= 6.
+
Returns number
Since
v0.11.15
+
readUint16BE
readUint16BE(offset?): number
Parameters
Optionaloffset: number
Returns number
Alias
Buffer.readUInt16BE
+
Since
v14.9.0, v12.19.0
+
readUint16LE
readUint16LE(offset?): number
Parameters
Optionaloffset: number
Returns number
Alias
Buffer.readUInt16LE
+
Since
v14.9.0, v12.19.0
+
readUint32BE
readUint32BE(offset?): number
Parameters
Optionaloffset: number
Returns number
Alias
Buffer.readUInt32BE
+
Since
v14.9.0, v12.19.0
+
readUint32LE
readUint32LE(offset?): number
Parameters
Optionaloffset: number
Returns number
Alias
Buffer.readUInt32LE
+
Since
v14.9.0, v12.19.0
+
readUint8
readUint8(offset?): number
Parameters
Optionaloffset: number
Returns number
Alias
Buffer.readUInt8
+
Since
v14.9.0, v12.19.0
+
readUintBE
readUintBE(offset, byteLength): number
Parameters
offset: number
byteLength: number
Returns number
Alias
Buffer.readUIntBE
+
Since
v14.9.0, v12.19.0
+
readUintLE
readUintLE(offset, byteLength): number
Parameters
offset: number
byteLength: number
Returns number
Alias
Buffer.readUIntLE
+
Since
v14.9.0, v12.19.0
+
reduce
reduce(callbackfn): number
Calls the specified callback function for all the elements in an array. The return value of
+the callback function is the accumulated result, and is provided as an argument in the next
+call to the callback function.
Calls the specified callback function for all the elements in an array. The return value of
+the callback function is the accumulated result, and is provided as an argument in the next
+call to the callback function.
If initialValue is specified, it is used as the initial value to start
+the accumulation. The first call to the callbackfn function provides this value as an argument
+instead of an array value.
Calls the specified callback function for all the elements in an array, in descending order.
+The return value of the callback function is the accumulated result, and is provided as an
+argument in the next call to the callback function.
Calls the specified callback function for all the elements in an array, in descending order.
+The return value of the callback function is the accumulated result, and is provided as an
+argument in the next call to the callback function.
If initialValue is specified, it is used as the initial value to start
+the accumulation. The first call to the callbackfn function provides this value as an argument
+instead of an array value.
Returns a new Buffer that references the same memory as the original, but
+offset and cropped by the start and end indices.
+
This method is not compatible with the Uint8Array.prototype.slice(),
+which is a superclass of Buffer. To copy the slice, useUint8Array.prototype.slice().
// With buf.slice(), the original buffer is modified. constnotReallyCopiedBuf = buf.slice(); notReallyCopiedBuf[0]++; console.log(notReallyCopiedBuf.toString()); // Prints: cuffer console.log(buf.toString()); // Also prints: cuffer (!)
+
Determines whether the specified callback function returns true for any element of an array.
+
Parameters
predicate: ((value, index, array) => unknown)
A function that accepts up to three arguments. The some method calls
+the predicate function for each element in the array until the predicate returns a value
+which is coercible to the Boolean value true, or until the end of the array.
+
(value, index, array): unknown
Parameters
value: number
index: number
array: Uint8Array
Returns unknown
OptionalthisArg: any
An object to which the this keyword can refer in the predicate function.
+If thisArg is omitted, undefined is used as the this value.
+
Returns boolean
sort
sort(compareFn?): this
Sorts an array.
+
Parameters
OptionalcompareFn: ((a, b) => number)
Function used to determine the order of the elements. It is expected to return
+a negative value if first argument is less than second argument, zero if they're equal and a positive
+value otherwise. If omitted, the elements are sorted in ascending order.
Interprets buf as an array of unsigned 16-bit integers and swaps the
+byte order in-place. Throws ERR_INVALID_BUFFER_SIZE if buf.length is not a multiple of 2.
Interprets buf as an array of unsigned 32-bit integers and swaps the
+byte order in-place. Throws ERR_INVALID_BUFFER_SIZE if buf.length is not a multiple of 4.
console.log(buf2.toString('hex')); // Prints: 74c3a97374 console.log(buf2.toString('utf8', 0, 3)); // Prints: té console.log(buf2.toString(undefined, 0, 3)); // Prints: té
+
+
Parameters
Optionalencoding: BufferEncoding
The character encoding to use.
+
Optionalstart: number
The byte offset to start decoding at.
+
Optionalend: number
The byte offset to stop decoding at (not inclusive).
+
Returns string
Since
v0.1.90
+
valueOf
valueOf(): Uint8Array
Returns the primitive value of the specified object.
+
Returns Uint8Array
values
values(): ArrayIterator<number>
Returns an list of values in the array
+
Returns ArrayIterator<number>
write
write(string, encoding?): number
Writes string to buf at offset according to the character encoding inencoding. The length parameter is the number of bytes to write. If buf did
+not contain enough space to fit the entire string, only part of string will be
+written. However, partially encoded characters will not be written.
Number of bytes to skip before starting to write. Must satisfy: 0 <= offset <= buf.length - 8.
+
Returns number
offset plus the number of bytes written.
+
Since
v12.0.0, v10.20.0
+
writeBigUInt64BE
writeBigUInt64BE(value, offset?): number
Writes value to buf at the specified offset as big-endian.
+
This function is also available under the writeBigUint64BE alias.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(8);
buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
console.log(buf); // Prints: <Buffer de ca fa fe ca ce fa de>
+
+
Parameters
value: bigint
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy: 0 <= offset <= buf.length - 8.
+
Returns number
offset plus the number of bytes written.
+
Since
v12.0.0, v10.20.0
+
writeBigUInt64LE
writeBigUInt64LE(value, offset?): number
Writes value to buf at the specified offset as little-endian
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(8);
buf.writeBigUInt64LE(0xdecafafecacefaden, 0);
console.log(buf); // Prints: <Buffer de fa ce ca fe fa ca de>
+
+
This function is also available under the writeBigUint64LE alias.
+
Parameters
value: bigint
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy: 0 <= offset <= buf.length - 8.
+
Returns number
offset plus the number of bytes written.
+
Since
v12.0.0, v10.20.0
+
writeBigUint64BE
writeBigUint64BE(value, offset?): number
Parameters
value: bigint
Optionaloffset: number
Returns number
Alias
Buffer.writeBigUInt64BE
+
Since
v14.10.0, v12.19.0
+
writeBigUint64LE
writeBigUint64LE(value, offset?): number
Parameters
value: bigint
Optionaloffset: number
Returns number
Alias
Buffer.writeBigUInt64LE
+
Since
v14.10.0, v12.19.0
+
writeDoubleBE
writeDoubleBE(value, offset?): number
Writes value to buf at the specified offset as big-endian. The value must be a JavaScript number. Behavior is undefined when value is anything
+other than a JavaScript number.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(8);
buf.writeDoubleBE(123.456, 0);
console.log(buf); // Prints: <Buffer 40 5e dd 2f 1a 9f be 77>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 8.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeDoubleLE
writeDoubleLE(value, offset?): number
Writes value to buf at the specified offset as little-endian. The value must be a JavaScript number. Behavior is undefined when value is anything
+other than a JavaScript number.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(8);
buf.writeDoubleLE(123.456, 0);
console.log(buf); // Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 8.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeFloatBE
writeFloatBE(value, offset?): number
Writes value to buf at the specified offset as big-endian. Behavior is
+undefined when value is anything other than a JavaScript number.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(4);
buf.writeFloatBE(0xcafebabe, 0);
console.log(buf); // Prints: <Buffer 4f 4a fe bb>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeFloatLE
writeFloatLE(value, offset?): number
Writes value to buf at the specified offset as little-endian. Behavior is
+undefined when value is anything other than a JavaScript number.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(4);
buf.writeFloatLE(0xcafebabe, 0);
console.log(buf); // Prints: <Buffer bb fe 4a 4f>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeInt16BE
writeInt16BE(value, offset?): number
Writes value to buf at the specified offset as big-endian. The value must be a valid signed 16-bit integer. Behavior is undefined when value is
+anything other than a signed 16-bit integer.
+
The value is interpreted and written as a two's complement signed integer.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(2);
buf.writeInt16BE(0x0102, 0);
console.log(buf); // Prints: <Buffer 01 02>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 2.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeInt16LE
writeInt16LE(value, offset?): number
Writes value to buf at the specified offset as little-endian. The value must be a valid signed 16-bit integer. Behavior is undefined when value is
+anything other than a signed 16-bit integer.
+
The value is interpreted and written as a two's complement signed integer.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(2);
buf.writeInt16LE(0x0304, 0);
console.log(buf); // Prints: <Buffer 04 03>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 2.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeInt32BE
writeInt32BE(value, offset?): number
Writes value to buf at the specified offset as big-endian. The value must be a valid signed 32-bit integer. Behavior is undefined when value is
+anything other than a signed 32-bit integer.
+
The value is interpreted and written as a two's complement signed integer.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeInt32LE
writeInt32LE(value, offset?): number
Writes value to buf at the specified offset as little-endian. The value must be a valid signed 32-bit integer. Behavior is undefined when value is
+anything other than a signed 32-bit integer.
+
The value is interpreted and written as a two's complement signed integer.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeInt8
writeInt8(value, offset?): number
Writes value to buf at the specified offset. value must be a valid
+signed 8-bit integer. Behavior is undefined when value is anything other than
+a signed 8-bit integer.
+
value is interpreted and written as a two's complement signed integer.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(2);
buf.writeInt8(2, 0); buf.writeInt8(-2, 1);
console.log(buf); // Prints: <Buffer 02 fe>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 1.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.0
+
writeIntBE
writeIntBE(value, offset, byteLength): number
Writes byteLength bytes of value to buf at the specified offsetas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined whenvalue is anything other than a
+signed integer.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to write. Must satisfy 0 < byteLength <= 6.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeIntLE
writeIntLE(value, offset, byteLength): number
Writes byteLength bytes of value to buf at the specified offsetas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
+when value is anything other than a signed integer.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to write. Must satisfy 0 < byteLength <= 6.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.11.15
+
writeUInt16BE
writeUInt16BE(value, offset?): number
Writes value to buf at the specified offset as big-endian. The value must be a valid unsigned 16-bit integer. Behavior is undefined when valueis anything other than an
+unsigned 16-bit integer.
+
This function is also available under the writeUint16BE alias.
console.log(buf); // Prints: <Buffer de ad be ef>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 2.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeUInt16LE
writeUInt16LE(value, offset?): number
Writes value to buf at the specified offset as little-endian. The value must be a valid unsigned 16-bit integer. Behavior is undefined when value is
+anything other than an unsigned 16-bit integer.
+
This function is also available under the writeUint16LE alias.
console.log(buf); // Prints: <Buffer ad de ef be>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 2.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeUInt32BE
writeUInt32BE(value, offset?): number
Writes value to buf at the specified offset as big-endian. The value must be a valid unsigned 32-bit integer. Behavior is undefined when valueis anything other than an
+unsigned 32-bit integer.
+
This function is also available under the writeUint32BE alias.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(4);
buf.writeUInt32BE(0xfeedface, 0);
console.log(buf); // Prints: <Buffer fe ed fa ce>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeUInt32LE
writeUInt32LE(value, offset?): number
Writes value to buf at the specified offset as little-endian. The value must be a valid unsigned 32-bit integer. Behavior is undefined when value is
+anything other than an unsigned 32-bit integer.
+
This function is also available under the writeUint32LE alias.
+
import { Buffer } from'node:buffer';
constbuf = Buffer.allocUnsafe(4);
buf.writeUInt32LE(0xfeedface, 0);
console.log(buf); // Prints: <Buffer ce fa ed fe>
+
+
Parameters
value: number
Number to be written to buf.
+
Optionaloffset: number
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 4.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeUInt8
writeUInt8(value, offset?): number
Writes value to buf at the specified offset. value must be a
+valid unsigned 8-bit integer. Behavior is undefined when value is anything
+other than an unsigned 8-bit integer.
+
This function is also available under the writeUint8 alias.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - 1.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.0
+
writeUIntBE
writeUIntBE(value, offset, byteLength): number
Writes byteLength bytes of value to buf at the specified offsetas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
+when value is anything other than an unsigned integer.
+
This function is also available under the writeUintBE alias.
Number of bytes to skip before starting to write. Must satisfy 0 <= offset <= buf.length - byteLength.
+
byteLength: number
Number of bytes to write. Must satisfy 0 < byteLength <= 6.
+
Returns number
offset plus the number of bytes written.
+
Since
v0.5.5
+
writeUIntLE
writeUIntLE(value, offset, byteLength): number
Writes byteLength bytes of value to buf at the specified offsetas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
+when value is anything other than an unsigned integer.
+
This function is also available under the writeUintLE alias.
\ 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..522cb255a
--- /dev/null
+++ b/modules/_zk_kit_baby_jubjub.html
@@ -0,0 +1,78 @@
+@zk-kit/baby-jubjub | zk-kit
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.
import { packPoint, unpackPoint, Base8, mulPointEscalar, Point, addPoint } from"@zk-kit/baby-jubjub"
// Define two points on the BabyJubJub curve. constp1: Point<bigint> = [BigInt(0), BigInt(1)] // Point at infinity (neutral element). constp2: Point<bigint> = [BigInt(1), BigInt(0)] // Example point.
// Add the two points on the curve. constp3 = addPoint(p1, p2)
// Add the result with Base8, another point on the curve, to get a new point. constsecretScalar = addPoint(Base8, p3)
// Multiply the base point by the x-coordinate of the secret scalar to get the public key. constpublicKey = mulPointEscalar(Base8, secretScalar[0])
// Pack the public key into a compressed format. constpackedPoint = packPoint(publicKey)
// Unpack the compressed public key back into its original form. constunpackedPoint = 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 }
+
\ No newline at end of file
diff --git a/modules/_zk_kit_eddsa_poseidon.html b/modules/_zk_kit_eddsa_poseidon.html
new file mode 100644
index 000000000..1371cbb2b
--- /dev/null
+++ b/modules/_zk_kit_eddsa_poseidon.html
@@ -0,0 +1,91 @@
+@zk-kit/eddsa-poseidon | zk-kit
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.
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.
The public key is generated using BLAKE by default and BLAKE2 if specified in the import as follows: import { ... } from "@zk-kit/eddsa-poseidon/blake-2b".
\ No newline at end of file
diff --git a/modules/_zk_kit_imt.html b/modules/_zk_kit_imt.html
new file mode 100644
index 000000000..8e3b0653e
--- /dev/null
+++ b/modules/_zk_kit_imt.html
@@ -0,0 +1,67 @@
+@zk-kit/imt | zk-kit
[!WARNING] If you are looking for the first version of this package, please visit this link.
+
+
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.
/** * 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). */
constdepth = 16 constzeroValue = 0 constarity = 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. */ consttree = newIMT(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)
// Get the index of the leaf with value 3. constidx = 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. */ constproof = tree.createProof(1) // true console.log(tree.verifyProof(proof))
+
\ No newline at end of file
diff --git a/modules/_zk_kit_lazytower.html b/modules/_zk_kit_lazytower.html
new file mode 100644
index 000000000..c4b5492d0
--- /dev/null
+++ b/modules/_zk_kit_lazytower.html
@@ -0,0 +1,67 @@
+@zk-kit/lazytower | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_lean_imt.html b/modules/_zk_kit_lean_imt.html
new file mode 100644
index 000000000..211fd8ccf
--- /dev/null
+++ b/modules/_zk_kit_lean_imt.html
@@ -0,0 +1,66 @@
+@zk-kit/lean-imt | zk-kit
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.
// Get the index of the leaf with value 3n. constidx = tree.indexOf(3n) // 1 console.log(idx)
// Check if the tree contains a leaf with value 4n. consthas = 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. constproof = tree.generateProof(1) // true console.log(tree.verifyProof(proof))
// Export all the tree nodes. constnodes = tree.export()
// Import the nodes. consttree2 = LeanIMT.import(hash, nodes)
// Node types are converted from strings to bigints by default. // The third parameter can be used to convert strings to other types.
// Import the nodes converting their types to numbers. consttree3 = LeanIMT.import<number>(hash, nodes, Number)
+
\ No newline at end of file
diff --git a/modules/_zk_kit_logical_expressions.html b/modules/_zk_kit_logical_expressions.html
new file mode 100644
index 000000000..cd2af7b8f
--- /dev/null
+++ b/modules/_zk_kit_logical_expressions.html
@@ -0,0 +1,89 @@
+@zk-kit/logical-expressions | zk-kit
This library facilitates the work with logical (boolean) expressions. It allows you to tokenize and evaluate any logical expression. It supports the use of parentheses.
Evaluates a tokenized logical (boolean) expression.
+
There is no need to verify the correctness of the logical expression before calling the evaluate function, as this will be checked during the evaluation. If the expression is incorrect, an error will be thrown automatically.
+
Example of correct logical expression: "true and false".
+
Example of incorrect logical expression: "true true and false".
\ No newline at end of file
diff --git a/modules/_zk_kit_poseidon_cipher.html b/modules/_zk_kit_poseidon_cipher.html
new file mode 100644
index 000000000..3a3e45f65
--- /dev/null
+++ b/modules/_zk_kit_poseidon_cipher.html
@@ -0,0 +1,80 @@
+@zk-kit/poseidon-cipher | zk-kit
// BabyJubJub random value used as private key. constprivateKey = BigInt("10108149867830299554549347844489388280570828384194562713227904027271736843407")
console.log(privateKey)
// The BabyJubJub public key derived from the private key. constpublicKey = [ 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. */ constencryptionKey = [ BigInt("18215233274609902892566361706948385597370728108990013889912246034099844508236"), BigInt("14884395706232754242497822954958766875005771827082919466711779658153477561231") ] /** [ 18215233274609902892566361706948385597370728108990013889912246034099844508236n, 14884395706232754242497822954958766875005771827082919466711779658153477561231n ] */ console.log(encryptionKey)
// The plaintext to be encrypted. constplainText = [BigInt(0), BigInt(1)] // The unique random value. constnonce = BigInt(5)
\ No newline at end of file
diff --git a/modules/_zk_kit_poseidon_proof.html b/modules/_zk_kit_poseidon_proof.html
new file mode 100644
index 000000000..362ff1b2e
--- /dev/null
+++ b/modules/_zk_kit_poseidon_proof.html
@@ -0,0 +1,92 @@
+@zk-kit/poseidon-proof | zk-kit
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:
[!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.
// A public value used to contextualize the cryptographic proof and calculate the nullifier. constscope = "scope" // The message (preimage) to prove (secret). constmessages = [1, 2]
// Generate the proof. constfullProof = awaitgenerate(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.
\ No newline at end of file
diff --git a/modules/_zk_kit_smt.html b/modules/_zk_kit_smt.html
new file mode 100644
index 000000000..8570d501d
--- /dev/null
+++ b/modules/_zk_kit_smt.html
@@ -0,0 +1,82 @@
+@zk-kit/smt | zk-kit
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.
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.conversions.html b/modules/_zk_kit_utils.conversions.html
new file mode 100644
index 000000000..9b1fe5720
--- /dev/null
+++ b/modules/_zk_kit_utils.conversions.html
@@ -0,0 +1,17 @@
+conversions | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.crypto.html b/modules/_zk_kit_utils.crypto.html
new file mode 100644
index 000000000..2228a9b72
--- /dev/null
+++ b/modules/_zk_kit_utils.crypto.html
@@ -0,0 +1,2 @@
+crypto | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.errorHandlers.html b/modules/_zk_kit_utils.errorHandlers.html
new file mode 100644
index 000000000..4fc448478
--- /dev/null
+++ b/modules/_zk_kit_utils.errorHandlers.html
@@ -0,0 +1,15 @@
+errorHandlers | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.html b/modules/_zk_kit_utils.html
new file mode 100644
index 000000000..d2a308050
--- /dev/null
+++ b/modules/_zk_kit_utils.html
@@ -0,0 +1,123 @@
+@zk-kit/utils | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.packing.html b/modules/_zk_kit_utils.packing.html
new file mode 100644
index 000000000..d5b0b6432
--- /dev/null
+++ b/modules/_zk_kit_utils.packing.html
@@ -0,0 +1,3 @@
+packing | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.scalar.html b/modules/_zk_kit_utils.scalar.html
new file mode 100644
index 000000000..4a77e3243
--- /dev/null
+++ b/modules/_zk_kit_utils.scalar.html
@@ -0,0 +1,7 @@
+scalar | zk-kit
\ No newline at end of file
diff --git a/modules/_zk_kit_utils.typeChecks.html b/modules/_zk_kit_utils.typeChecks.html
new file mode 100644
index 000000000..96afd8262
--- /dev/null
+++ b/modules/_zk_kit_utils.typeChecks.html
@@ -0,0 +1,18 @@
+typeChecks | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_baby_jubjub.Point.html b/types/_zk_kit_baby_jubjub.Point.html
new file mode 100644
index 000000000..334bbbdf4
--- /dev/null
+++ b/types/_zk_kit_baby_jubjub.Point.html
@@ -0,0 +1 @@
+Point | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_eddsa_poseidon.Signature.html b/types/_zk_kit_eddsa_poseidon.Signature.html
new file mode 100644
index 000000000..26b188e0a
--- /dev/null
+++ b/types/_zk_kit_eddsa_poseidon.Signature.html
@@ -0,0 +1 @@
+Signature | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_imt.IMTHashFunction.html b/types/_zk_kit_imt.IMTHashFunction.html
new file mode 100644
index 000000000..9db2ec629
--- /dev/null
+++ b/types/_zk_kit_imt.IMTHashFunction.html
@@ -0,0 +1,3 @@
+IMTHashFunction | zk-kit
\ 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..f7c17f551
--- /dev/null
+++ b/types/_zk_kit_imt.IMTMerkleProof.html
@@ -0,0 +1,9 @@
+IMTMerkleProof | zk-kit
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
leafIndex: number
pathIndices: number[]
root: any
siblings: any[]
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/types/_zk_kit_imt.IMTNode.html b/types/_zk_kit_imt.IMTNode.html
new file mode 100644
index 000000000..3b941033e
--- /dev/null
+++ b/types/_zk_kit_imt.IMTNode.html
@@ -0,0 +1,2 @@
+IMTNode | zk-kit
It represents a node of the tree, which can be any value.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/types/_zk_kit_lazytower.LazyTowerHashChainProof.html b/types/_zk_kit_lazytower.LazyTowerHashChainProof.html
new file mode 100644
index 000000000..be340727d
--- /dev/null
+++ b/types/_zk_kit_lazytower.LazyTowerHashChainProof.html
@@ -0,0 +1 @@
+LazyTowerHashChainProof | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_lean_imt.LeanIMTHashFunction.html b/types/_zk_kit_lean_imt.LeanIMTHashFunction.html
new file mode 100644
index 000000000..6b265bc1a
--- /dev/null
+++ b/types/_zk_kit_lean_imt.LeanIMTHashFunction.html
@@ -0,0 +1,3 @@
+LeanIMTHashFunction | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_lean_imt.LeanIMTMerkleProof.html b/types/_zk_kit_lean_imt.LeanIMTMerkleProof.html
new file mode 100644
index 000000000..34a02dafb
--- /dev/null
+++ b/types/_zk_kit_lean_imt.LeanIMTMerkleProof.html
@@ -0,0 +1,9 @@
+LeanIMTMerkleProof | zk-kit
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.
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.BigIntOutput.html b/types/_zk_kit_poseidon_cipher.BigIntOutput.html
new file mode 100644
index 000000000..fa025f63a
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.BigIntOutput.html
@@ -0,0 +1 @@
+BigIntOutput | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.CipherText.html b/types/_zk_kit_poseidon_cipher.CipherText.html
new file mode 100644
index 000000000..fe526209d
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.CipherText.html
@@ -0,0 +1 @@
+CipherText | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.EncryptionKey.html b/types/_zk_kit_poseidon_cipher.EncryptionKey.html
new file mode 100644
index 000000000..c7ad1a9b6
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.EncryptionKey.html
@@ -0,0 +1 @@
+EncryptionKey | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.Nonce.html b/types/_zk_kit_poseidon_cipher.Nonce.html
new file mode 100644
index 000000000..53b1e8a06
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.Nonce.html
@@ -0,0 +1 @@
+Nonce | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.PlainText.html b/types/_zk_kit_poseidon_cipher.PlainText.html
new file mode 100644
index 000000000..51497f247
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.PlainText.html
@@ -0,0 +1 @@
+PlainText | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_cipher.StringifiedInput.html b/types/_zk_kit_poseidon_cipher.StringifiedInput.html
new file mode 100644
index 000000000..49e3118d3
--- /dev/null
+++ b/types/_zk_kit_poseidon_cipher.StringifiedInput.html
@@ -0,0 +1 @@
+StringifiedInput | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_poseidon_proof.PoseidonProof.html b/types/_zk_kit_poseidon_proof.PoseidonProof.html
new file mode 100644
index 000000000..1dfbadf7f
--- /dev/null
+++ b/types/_zk_kit_poseidon_proof.PoseidonProof.html
@@ -0,0 +1 @@
+PoseidonProof | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.ChildNodes.html b/types/_zk_kit_smt.ChildNodes.html
new file mode 100644
index 000000000..346646bfc
--- /dev/null
+++ b/types/_zk_kit_smt.ChildNodes.html
@@ -0,0 +1 @@
+ChildNodes | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.Entry.html b/types/_zk_kit_smt.Entry.html
new file mode 100644
index 000000000..b4c87aebe
--- /dev/null
+++ b/types/_zk_kit_smt.Entry.html
@@ -0,0 +1 @@
+Entry | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.EntryMark.html b/types/_zk_kit_smt.EntryMark.html
new file mode 100644
index 000000000..e47cad937
--- /dev/null
+++ b/types/_zk_kit_smt.EntryMark.html
@@ -0,0 +1 @@
+EntryMark | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.HashFunction.html b/types/_zk_kit_smt.HashFunction.html
new file mode 100644
index 000000000..8555f912f
--- /dev/null
+++ b/types/_zk_kit_smt.HashFunction.html
@@ -0,0 +1 @@
+HashFunction | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.Key.html b/types/_zk_kit_smt.Key.html
new file mode 100644
index 000000000..efe4bd826
--- /dev/null
+++ b/types/_zk_kit_smt.Key.html
@@ -0,0 +1 @@
+Key | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.Node.html b/types/_zk_kit_smt.Node.html
new file mode 100644
index 000000000..641f1db27
--- /dev/null
+++ b/types/_zk_kit_smt.Node.html
@@ -0,0 +1 @@
+Node | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.Siblings.html b/types/_zk_kit_smt.Siblings.html
new file mode 100644
index 000000000..d53c4e172
--- /dev/null
+++ b/types/_zk_kit_smt.Siblings.html
@@ -0,0 +1 @@
+Siblings | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_smt.Value.html b/types/_zk_kit_smt.Value.html
new file mode 100644
index 000000000..726cf09fe
--- /dev/null
+++ b/types/_zk_kit_smt.Value.html
@@ -0,0 +1 @@
+Value | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_utils.BigNumber.html b/types/_zk_kit_utils.BigNumber.html
new file mode 100644
index 000000000..0ed7497ba
--- /dev/null
+++ b/types/_zk_kit_utils.BigNumber.html
@@ -0,0 +1 @@
+BigNumber | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_utils.BigNumberish.html b/types/_zk_kit_utils.BigNumberish.html
new file mode 100644
index 000000000..93c467300
--- /dev/null
+++ b/types/_zk_kit_utils.BigNumberish.html
@@ -0,0 +1 @@
+BigNumberish | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_utils.PackedGroth16Proof.html b/types/_zk_kit_utils.PackedGroth16Proof.html
new file mode 100644
index 000000000..a1dac824b
--- /dev/null
+++ b/types/_zk_kit_utils.PackedGroth16Proof.html
@@ -0,0 +1 @@
+PackedGroth16Proof | zk-kit
\ No newline at end of file
diff --git a/types/_zk_kit_utils.typeChecks.SupportedType.html b/types/_zk_kit_utils.typeChecks.SupportedType.html
new file mode 100644
index 000000000..9bc9f5e54
--- /dev/null
+++ b/types/_zk_kit_utils.typeChecks.SupportedType.html
@@ -0,0 +1 @@
+SupportedType | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_baby_jubjub.Base8.html b/variables/_zk_kit_baby_jubjub.Base8.html
new file mode 100644
index 000000000..45c2adb73
--- /dev/null
+++ b/variables/_zk_kit_baby_jubjub.Base8.html
@@ -0,0 +1 @@
+Base8 | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_baby_jubjub.Fr.html b/variables/_zk_kit_baby_jubjub.Fr.html
new file mode 100644
index 000000000..18cb5ab92
--- /dev/null
+++ b/variables/_zk_kit_baby_jubjub.Fr.html
@@ -0,0 +1 @@
+Fr | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_baby_jubjub.order.html b/variables/_zk_kit_baby_jubjub.order.html
new file mode 100644
index 000000000..c7f98db56
--- /dev/null
+++ b/variables/_zk_kit_baby_jubjub.order.html
@@ -0,0 +1 @@
+order | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_baby_jubjub.r.html b/variables/_zk_kit_baby_jubjub.r.html
new file mode 100644
index 000000000..6b7c62df2
--- /dev/null
+++ b/variables/_zk_kit_baby_jubjub.r.html
@@ -0,0 +1,3 @@
+r | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_baby_jubjub.subOrder.html b/variables/_zk_kit_baby_jubjub.subOrder.html
new file mode 100644
index 000000000..e7f8cbc56
--- /dev/null
+++ b/variables/_zk_kit_baby_jubjub.subOrder.html
@@ -0,0 +1 @@
+subOrder | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_eddsa_poseidon.EdDSAPoseidon.html b/variables/_zk_kit_eddsa_poseidon.EdDSAPoseidon.html
new file mode 100644
index 000000000..a2dc6b759
--- /dev/null
+++ b/variables/_zk_kit_eddsa_poseidon.EdDSAPoseidon.html
@@ -0,0 +1 @@
+EdDSAPoseidon | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_poseidon_cipher.C.html b/variables/_zk_kit_poseidon_cipher.C.html
new file mode 100644
index 000000000..61804aafa
--- /dev/null
+++ b/variables/_zk_kit_poseidon_cipher.C.html
@@ -0,0 +1 @@
+C | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_poseidon_cipher.M.html b/variables/_zk_kit_poseidon_cipher.M.html
new file mode 100644
index 000000000..257f9f8b6
--- /dev/null
+++ b/variables/_zk_kit_poseidon_cipher.M.html
@@ -0,0 +1 @@
+M | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_utils.Buffer-1.html b/variables/_zk_kit_utils.Buffer-1.html
new file mode 100644
index 000000000..ab6985b24
--- /dev/null
+++ b/variables/_zk_kit_utils.Buffer-1.html
@@ -0,0 +1 @@
+Buffer | zk-kit
\ No newline at end of file
diff --git a/variables/_zk_kit_utils.typeChecks.supportedTypes.html b/variables/_zk_kit_utils.typeChecks.supportedTypes.html
new file mode 100644
index 000000000..5b0ad4e38
--- /dev/null
+++ b/variables/_zk_kit_utils.typeChecks.supportedTypes.html
@@ -0,0 +1 @@
+supportedTypes | zk-kit
+ 
+
+
+ 
+
+
+ 
&style=flat-square&logo=coveralls)
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+ 
+
+
+ 
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.
+