The SemaphoreEthers class provides a high-level interface to interact with the Semaphore smart contract
+using the ethers.js library. It encapsulates all necessary functionalities to connect to Ethereum networks,
+manage contract instances, and perform operations such as retrieving group information or checking group memberships.
+This class simplifies the interaction with the Ethereum blockchain by abstracting the details of network connections
+and contract interactions.
new SemaphoreEthers(networkOrEthereumURL?, options?): SemaphoreEthers
Constructs a new SemaphoreEthers instance, initializing it with a network or a custom Ethereum node URL,
+and optional configuration settings for the ethers provider and contract.
+
Parameters
networkOrEthereumURL: string = defaultNetwork
The Ethereum network name or a custom JSON-RPC URL to connect to.
Retrieves detailed information about a specific group by its ID. This method queries the Semaphore contract
+to get the group's admin, Merkle tree root, depth, and size.
A promise that resolves to a GroupResponse object.
+
getGroupIds
getGroupIds(): Promise<string[]>
Fetches the list of group IDs from the Semaphore contract by querying the "GroupCreated" events.
+
Returns Promise<string[]>
A promise that resolves to an array of group IDs as strings.
+
getGroupMembers
getGroupMembers(groupId): Promise<string[]>
Fetches a list of members from a specific group. This method queries the Semaphore contract for events
+related to member additions and updates, and constructs the list of current group members.
+
Parameters
groupId: string
The unique identifier of the group.
+
Returns Promise<string[]>
A promise that resolves to an array of member identity commitments as strings.
+
getGroupValidatedProofs
getGroupValidatedProofs(groupId): Promise<any>
Retrieves a list of validated proofs for a specific group. This method queries the Semaphore contract
+for "ProofValidated" events and returns details about each proof.
+
Parameters
groupId: string
The unique identifier of the group.
+
Returns Promise<any>
A promise that resolves to an array of validated proofs.
+
isGroupMember
isGroupMember(groupId, member): Promise<boolean>
Checks whether a specific member is part of a group. This method queries the Semaphore contract
+to determine if the provided identity commitment is a member of the specified group.
+
Parameters
groupId: string
The unique identifier of the group.
+
member: string
The identity commitment of the member to check.
+
Returns Promise<boolean>
A promise that resolves to true if the member is part of the group, otherwise false.
\ No newline at end of file
diff --git a/classes/_semaphore_protocol_data.SemaphoreSubgraph.html b/classes/_semaphore_protocol_data.SemaphoreSubgraph.html
new file mode 100644
index 000000000..38ffb3a59
--- /dev/null
+++ b/classes/_semaphore_protocol_data.SemaphoreSubgraph.html
@@ -0,0 +1,47 @@
+SemaphoreSubgraph | Semaphore SDK
The SemaphoreSubgraph class provides an interface to interact with the Semaphore smart contract
+via subgraph queries. It enables operations such as retrieving lists of group members and validated proofs,
+as well as checking membership within groups.
+Each group in Semaphore is represented as a LeanIMT
+(Lean Incremental Merkle Tree). This class supports interaction through either a
+SupportedNetwork or a direct URL to the subgraph. The subgraphs themselves are hosted on
+The Graph protocol, facilitating efficient and decentralized query processing.
Initializes the SemaphoreSubgraph instance with a supported network or a custom subgraph URL.
+This allows to interact with the Semaphore smart contract through the specified endpoint.
+
Parameters
networkOrSubgraphURL: string = defaultNetwork
Either a supported network identifier or a direct URL to the subgraph.
Fetches detailed information about a specific group by its ID. This method can also retrieve
+members and validated proofs for the group if requested via options.
A promise that resolves to the details of the specified group.
+
getGroupIds
getGroupIds(): Promise<string[]>
Fetches a list of all group IDs from the subgraph. This method queries the subgraph to retrieve
+identifiers for all groups managed by the Semaphore smart contract.
+
Returns Promise<string[]>
A promise that resolves to an array of group IDs.
+
getGroupMembers
getGroupMembers(groupId): Promise<string[]>
Retrieves a list of members from a specific group.
+
Parameters
groupId: string
The unique identifier of the group.
+
Returns Promise<string[]>
A promise that resolves to an array of group members' identity commitments.
+
getGroupValidatedProofs
getGroupValidatedProofs(groupId): Promise<any[]>
Fetches a list of validated proofs for a specific group.
+
Parameters
groupId: string
The unique identifier of the group.
+
Returns Promise<any[]>
A promise that resolves to an array of validated proofs.
Retrieves detailed information about groups from the subgraph based on the provided options.
+This method can filter groups by various parameters and include additional details like members
+and validated proofs if specified in the options.
A promise that resolves to an array of group details.
+
isGroupMember
isGroupMember(groupId, member): Promise<boolean>
Determines whether a specific member is part of a group. This method queries the subgraph to check
+if the provided member's identity commitment exists within the specified group.
+
Parameters
groupId: string
The unique identifier of the group.
+
member: string
The identity commitment of the member to check.
+
Returns Promise<boolean>
A promise that resolves to true if the member is part of the group, otherwise false.
\ No newline at end of file
diff --git a/classes/_semaphore_protocol_group.Group.html b/classes/_semaphore_protocol_group.Group.html
new file mode 100644
index 000000000..aa4e51144
--- /dev/null
+++ b/classes/_semaphore_protocol_group.Group.html
@@ -0,0 +1,59 @@
+Group | Semaphore SDK
The Semaphore group is a LeanIMT
+(Lean Incremental Merkle Tree), i.e. an optimized version of the incremental binary Merkle tree
+used by Semaphore V3. The new tree does not use zero hashes, and its depth is dynamic.
+The members of a Semaphore group, or the leaves of a tree, are the identity commitments.
+Thanks to the properties of Merkle trees, it can be efficiently demonstrated that a group
+member belongs to the group.
+This class supports operations such as member addition, update, removal and Merkle proof
+generation and verification. Groups can also be exported or imported.
Creates a new instance of the Group. Optionally, a list of identity commitments can
+be passed as a parameter. Adding members in chunks is more efficient than adding
+them one by one with the addMember function.
Returns the members (i.e. identity commitments) of the group.
+
Returns bigint[]
The list of members of the group.
+
root
get root(): bigint
Returns the root hash of the tree.
+
Returns bigint
The root hash as a string.
+
size
get size(): number
Returns the size of the tree (i.e. number of leaves).
+
Returns number
The tree size as a number.
+
Methods
addMember
addMember(member): void
Adds a new member to the group.
+
Parameters
member: BigNumber
The new member to be added.
+
Returns void
addMembers
addMembers(members): void
Adds new members to the group.
+
Parameters
members: BigNumber[]
New members.
+
Returns void
export
export(): string
Enables the conversion of the group into a JSON string that
+can be re-used for future imports. This approach is beneficial for
+large groups, as it avoids re-calculating the tree hashes.
Imports an entire group by initializing the tree without calculating
+any hashes. Note that it is crucial to ensure the integrity of the
+exported group.
\ No newline at end of file
diff --git a/classes/_semaphore_protocol_identity.Identity.html b/classes/_semaphore_protocol_identity.Identity.html
new file mode 100644
index 000000000..e02284f72
--- /dev/null
+++ b/classes/_semaphore_protocol_identity.Identity.html
@@ -0,0 +1,69 @@
+Identity | Semaphore SDK
The Semaphore identity is essentially an EdDSA
+public/private key pair. The EdDSA implementation
+in this library uses Baby Jubjub for public key generation
+and Poseidon for signatures.
+In addition, the commitment, i.e. the hash of the public key, is used to represent
+Semaphore identities in groups, adding an additional layer of privacy and security.
+The private key of the identity can be exported as a base64 string.
Initializes the class attributes based on a given private key, which must be text or a buffer.
+If the private key is not passed as a parameter, a random private key will be generated.
+The EdDSAPoseidon class is used to generate the secret scalar and the public key.
+Additionally, the constructor computes a commitment of the public key using a hash function (Poseidon).
+
Parameters
OptionalprivateKey: string | Buffer | Uint8Array
The private key used to derive the public key (hexadecimal or string).
Generates a signature for a given message using the private key.
+This method demonstrates how to sign a message and could be used
+for authentication or data integrity.
Generates the commitment from the given public key.
+This static method is particularly useful after signature verification,
+as it allows retrieval of the corresponding commitment associated with the public key.
Returns a Semaphore identity based on a private key encoded as a base64 string.
+The private key will be converted to a buffer, regardless of its original type.
Verifies a signature against a given message and public key.
+This static method allows for the verification of signatures without needing
+an instance of the Identity class. It's useful for cases where you only have
+the public key, the message and a signature, and need to verify if they match.
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_proof.generateProof.html b/functions/_semaphore_protocol_proof.generateProof.html
new file mode 100644
index 000000000..a06a9f3b7
--- /dev/null
+++ b/functions/_semaphore_protocol_proof.generateProof.html
@@ -0,0 +1,20 @@
+generateProof | Semaphore SDK
It generates a Semaphore proof, i.e. a zero-knowledge proof that an identity that
+is part of a group has shared an anonymous message.
+The message may be any arbitrary user-defined value (e.g. a vote), or the hash of that value.
+The scope is a value used like a topic on which users can generate a valid proof only once,
+for example the id of an election in which voters can only vote once.
+The hash of the identity's scope and secret scalar is called a nullifier and can be
+used to verify whether that identity has already generated a valid proof in that scope.
+The depth of the tree determines which zero-knowledge artifacts to use to generate the proof.
+If it is not defined, it will be inferred from the group or Merkle proof passed as the second parameter.
+Finally, the artifacts themselves can be passed manually with file paths,
+or they will be automatically fetched.
+Please keep in mind that groups with 1 member or 2 members cannot be considered anonymous.
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_proof.packGroth16Proof.html b/functions/_semaphore_protocol_proof.packGroth16Proof.html
new file mode 100644
index 000000000..458478856
--- /dev/null
+++ b/functions/_semaphore_protocol_proof.packGroth16Proof.html
@@ -0,0 +1,4 @@
+packGroth16Proof | Semaphore SDK
Packs a Snarkjs Groth16 proof into a single list usable as calldata in Solidity (public signals are not included).
+
Parameters
proof: Groth16Proof
The Groth16 proof generated with SnarkJS.
+
Returns PackedGroth16Proof
Solidity calldata.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_proof.unpackGroth16Proof.html b/functions/_semaphore_protocol_proof.unpackGroth16Proof.html
new file mode 100644
index 000000000..3cf065a36
--- /dev/null
+++ b/functions/_semaphore_protocol_proof.unpackGroth16Proof.html
@@ -0,0 +1,4 @@
+unpackGroth16Proof | Semaphore SDK
Unpacks a PackedGroth16Proof Solidity calldata into its original form which is a SnarkJS Groth16 proof.
+
Parameters
proof: PackedGroth16Proof
Solidity calldata.
+
Returns Groth16Proof
The Groth16 proof compatible with SnarkJS.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_proof.verifyProof.html b/functions/_semaphore_protocol_proof.verifyProof.html
new file mode 100644
index 000000000..9a31fa895
--- /dev/null
+++ b/functions/_semaphore_protocol_proof.verifyProof.html
@@ -0,0 +1,5 @@
+verifyProof | Semaphore SDK
Verifies whether a Semaphore proof is valid. Depending on the depth of the tree used to
+generate the proof, a different verification key will be used.
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_utils.decodeMessage.html b/functions/_semaphore_protocol_utils.decodeMessage.html
new file mode 100644
index 000000000..c467dffe6
--- /dev/null
+++ b/functions/_semaphore_protocol_utils.decodeMessage.html
@@ -0,0 +1,9 @@
+decodeMessage | Semaphore SDK
Typically used for decoding on-chain Semaphore messages.
+When Semaphore messages are text they are converted to bigints before
+the proof is generated (and eventually sent on-chain).
+This function help devs converting bigint messages to text again.
+If the original message was not text the output of this
+function won't probably be human-readable text.
+
Parameters
message: BigNumberish
The Semaphore message as a bigint.
+
Returns string
The Semaphore message as a text.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_utils.getDeployedContract.html b/functions/_semaphore_protocol_utils.getDeployedContract.html
new file mode 100644
index 000000000..57ba9d7ec
--- /dev/null
+++ b/functions/_semaphore_protocol_utils.getDeployedContract.html
@@ -0,0 +1,5 @@
+getDeployedContract | Semaphore SDK
An object with name, address and start block of the deployed contract.
+
address: string
name: string
startBlock: number
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_utils.getHardhatNetworks.html b/functions/_semaphore_protocol_utils.getHardhatNetworks.html
new file mode 100644
index 000000000..2eda50b29
--- /dev/null
+++ b/functions/_semaphore_protocol_utils.getHardhatNetworks.html
@@ -0,0 +1,5 @@
+getHardhatNetworks | Semaphore SDK
Utility function to get an object compatible with the Hardhat 'networks' option.
+If the private key is not defined it returns an empty object.
+
Parameters
OptionalprivateKey: string
Private key to be used with networks.
+
Returns any
An object compatible with the Hardhat 'networks' option.
+
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/functions/_semaphore_protocol_utils.isSupportedNetwork.html b/functions/_semaphore_protocol_utils.isSupportedNetwork.html
new file mode 100644
index 000000000..61bb9108b
--- /dev/null
+++ b/functions/_semaphore_protocol_utils.isSupportedNetwork.html
@@ -0,0 +1,3 @@
+isSupportedNetwork | Semaphore SDK
Returns true if a network is supported by Semaphore, false otherwise.
+
Parameters
supportedNetwork: string
The network to be checked.
+
Returns boolean
Settings
Member Visibility
Theme
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..176daacab
--- /dev/null
+++ b/index.html
@@ -0,0 +1,318 @@
+Semaphore SDK
Semaphore is a generic privacy layer. Leveraging zero-knowledge technology, users can prove their membership in groups and send messages (extending from votes to endorsements) off-chain or across EVM-compatible blockchains, all without revealing their personal identity.
+
+
+
+
The core of the Semaphore protocol is in the circuit logic. However, Semaphore also provides Solidity contracts and JavaScript libraries to make the steps for offchain proof creation and onchain/offchain verification easier. To learn more about Semaphore visit semaphore.pse.dev.
+
+
[!IMPORTANT] Help Semaphore prosper by sharing your ideas with the PSE acceleration program.
yarnversion:bump <version> # e.g. yarn version:bump 2.0.0
+
+
It will create a commit and a git tag that will need to be pushed on the main branch. A workflow will be triggered and will
+publish the Semaphore packages on npm and release a new version on Github with its changelogs automatically.
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_data.html b/modules/_semaphore_protocol_data.html
new file mode 100644
index 000000000..daf8adcee
--- /dev/null
+++ b/modules/_semaphore_protocol_data.html
@@ -0,0 +1,113 @@
+@semaphore-protocol/data | Semaphore SDK
This library provides tools for querying and interacting with the Semaphore.sol smart contract. It supports both the Semaphore subgraph and direct Ethereum network connections via Ethers. Designed for use in both Node.js and browser environments, it facilitates the management of group data and verification processes within the Semaphore protocol.
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_group.html b/modules/_semaphore_protocol_group.html
new file mode 100644
index 000000000..cbc1c3e0a
--- /dev/null
+++ b/modules/_semaphore_protocol_group.html
@@ -0,0 +1,95 @@
+@semaphore-protocol/group | Semaphore SDK
This library is an abstraction of the LeanIMT data structure (part of @zk-kit/imt). The main goal is to make it easier to create offchain groups, which are also used to generate Semaphore proofs. Semaphore groups are actually Merkle trees, and the group members are tree leaves.
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_identity.html b/modules/_semaphore_protocol_identity.html
new file mode 100644
index 000000000..cde57f324
--- /dev/null
+++ b/modules/_semaphore_protocol_identity.html
@@ -0,0 +1,87 @@
+@semaphore-protocol/identity | Semaphore SDK
This library provides a class that can be used to create identities compatible with the Semaphore circuits. Each identity contains an EdDSA private key, its public key, and the identity commitment, which is the Poseidon hash of the public key.
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_proof.html b/modules/_semaphore_protocol_proof.html
new file mode 100644
index 000000000..608bcb7e9
--- /dev/null
+++ b/modules/_semaphore_protocol_proof.html
@@ -0,0 +1,84 @@
+@semaphore-protocol/proof | Semaphore SDK
This library provides utility functions to generate and verify Semaphore proofs compatible with the Semaphore circuits. Generating valid zero-knowledge proofs requires files that can only be obtained in an attested trusted-setup ceremony.
// snarkArtifacts are not provided. // So they will be automatically downloaded (see https://github.com/privacy-scaling-explorations/snark-artifacts). constproof1 = awaitgenerateProof(identity1, group, message, scope)
// You can also specify the maximum tree depth supported by the proof. constproof2 = awaitgenerateProof(identity2, group, message, scope, 20)
// You can also override our default zkey/wasm files. constproof3 = awaitgenerateProof(identity3, group, message, scope, 20, { wasm:"./semaphore.wasm", zkey:"./semaphore.zkey" })
+
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_utils.constants.html b/modules/_semaphore_protocol_utils.constants.html
new file mode 100644
index 000000000..98904cb32
--- /dev/null
+++ b/modules/_semaphore_protocol_utils.constants.html
@@ -0,0 +1,5 @@
+constants | Semaphore SDK
\ No newline at end of file
diff --git a/modules/_semaphore_protocol_utils.html b/modules/_semaphore_protocol_utils.html
new file mode 100644
index 000000000..470e6d1e7
--- /dev/null
+++ b/modules/_semaphore_protocol_utils.html
@@ -0,0 +1,70 @@
+@semaphore-protocol/utils | Semaphore SDK
For more information on the functions and modules provided by @semaphore-protocol/utils, please refer to the TypeDoc documentation.
+
// You can import functions/parameters from the main bundle. import { supportedNetworks, decodeMessage } from"@semaphore-protocol/utils"
// Or by using conditional exports. importsupportedNetworksfrom"@semaphore-protocol/utils/supported-networks" importdecodeMessagefrom"@semaphore-protocol/utils/decode-message"
+
\ No newline at end of file
diff --git a/types/_semaphore_protocol_data.EthersNetwork.html b/types/_semaphore_protocol_data.EthersNetwork.html
new file mode 100644
index 000000000..c12e50c7d
--- /dev/null
+++ b/types/_semaphore_protocol_data.EthersNetwork.html
@@ -0,0 +1 @@
+EthersNetwork | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_data.EthersOptions.html b/types/_semaphore_protocol_data.EthersOptions.html
new file mode 100644
index 000000000..ae20436a9
--- /dev/null
+++ b/types/_semaphore_protocol_data.EthersOptions.html
@@ -0,0 +1 @@
+EthersOptions | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_data.GroupOptions.html b/types/_semaphore_protocol_data.GroupOptions.html
new file mode 100644
index 000000000..8be07b02e
--- /dev/null
+++ b/types/_semaphore_protocol_data.GroupOptions.html
@@ -0,0 +1 @@
+GroupOptions | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_data.GroupResponse.html b/types/_semaphore_protocol_data.GroupResponse.html
new file mode 100644
index 000000000..db13b6837
--- /dev/null
+++ b/types/_semaphore_protocol_data.GroupResponse.html
@@ -0,0 +1 @@
+GroupResponse | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_group.MerkleProof.html b/types/_semaphore_protocol_group.MerkleProof.html
new file mode 100644
index 000000000..24048503a
--- /dev/null
+++ b/types/_semaphore_protocol_group.MerkleProof.html
@@ -0,0 +1,9 @@
+MerkleProof | Semaphore SDK
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/_semaphore_protocol_identity.Point.html b/types/_semaphore_protocol_identity.Point.html
new file mode 100644
index 000000000..61fab59fb
--- /dev/null
+++ b/types/_semaphore_protocol_identity.Point.html
@@ -0,0 +1 @@
+Point | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_identity.Signature.html b/types/_semaphore_protocol_identity.Signature.html
new file mode 100644
index 000000000..9a3807be9
--- /dev/null
+++ b/types/_semaphore_protocol_identity.Signature.html
@@ -0,0 +1 @@
+Signature | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_proof.SemaphoreProof.html b/types/_semaphore_protocol_proof.SemaphoreProof.html
new file mode 100644
index 000000000..3eaece922
--- /dev/null
+++ b/types/_semaphore_protocol_proof.SemaphoreProof.html
@@ -0,0 +1 @@
+SemaphoreProof | Semaphore SDK
\ No newline at end of file
diff --git a/types/_semaphore_protocol_utils.SupportedNetwork.html b/types/_semaphore_protocol_utils.SupportedNetwork.html
new file mode 100644
index 000000000..a3c8a09c7
--- /dev/null
+++ b/types/_semaphore_protocol_utils.SupportedNetwork.html
@@ -0,0 +1 @@
+SupportedNetwork | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.constants.MAX_DEPTH.html b/variables/_semaphore_protocol_utils.constants.MAX_DEPTH.html
new file mode 100644
index 000000000..ae90ea935
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.constants.MAX_DEPTH.html
@@ -0,0 +1 @@
+MAX_DEPTH | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.constants.MIN_DEPTH.html b/variables/_semaphore_protocol_utils.constants.MIN_DEPTH.html
new file mode 100644
index 000000000..de418ba5c
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.constants.MIN_DEPTH.html
@@ -0,0 +1 @@
+MIN_DEPTH | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.constants.SemaphoreABI.html b/variables/_semaphore_protocol_utils.constants.SemaphoreABI.html
new file mode 100644
index 000000000..67dbc31ae
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.constants.SemaphoreABI.html
@@ -0,0 +1 @@
+SemaphoreABI | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.constants.SemaphoreBytecode.html b/variables/_semaphore_protocol_utils.constants.SemaphoreBytecode.html
new file mode 100644
index 000000000..7f8581405
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.constants.SemaphoreBytecode.html
@@ -0,0 +1 @@
+SemaphoreBytecode | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.defaultNetwork.html b/variables/_semaphore_protocol_utils.defaultNetwork.html
new file mode 100644
index 000000000..93a1a33c2
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.defaultNetwork.html
@@ -0,0 +1 @@
+defaultNetwork | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.deployedContracts.html b/variables/_semaphore_protocol_utils.deployedContracts.html
new file mode 100644
index 000000000..89592f747
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.deployedContracts.html
@@ -0,0 +1 @@
+deployedContracts | Semaphore SDK
\ No newline at end of file
diff --git a/variables/_semaphore_protocol_utils.supportedNetworks.html b/variables/_semaphore_protocol_utils.supportedNetworks.html
new file mode 100644
index 000000000..7c7a0df74
--- /dev/null
+++ b/variables/_semaphore_protocol_utils.supportedNetworks.html
@@ -0,0 +1 @@
+supportedNetworks | Semaphore SDK
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
The SemaphoreEthers class provides a high-level interface to interact with the Semaphore smart contract +using the ethers.js library. It encapsulates all necessary functionalities to connect to Ethereum networks, +manage contract instances, and perform operations such as retrieving group information or checking group memberships. +This class simplifies the interaction with the Ethereum blockchain by abstracting the details of network connections +and contract interactions.
+