@crisp-e3/sdk 0.0.1-test

package/dist/src/constants.d.ts

@@ -0,0 +1,18 @@
+import { BFVParams } from './types';
+export declare const CRISP_SERVER_TOKEN_TREE_ENDPOINT = "state/token-holders";
+export declare const CRISP_SERVER_STATE_LITE_ENDPOINT = "state/lite";
+/**
+ * This is the maximum value for a vote (Yes or No). This is 2^28
+ * The minimum degree that BFV should use is 56 (to accommodate both Yes and No votes)
+ * If you change this value, make sure to update the circuit too.
+ */
+export declare const MAXIMUM_VOTE_VALUE = 268435456n;
+/**
+ * Default BFV parameters for the CRISP ZK inputs generator.
+ * These are the parameters used for the default testing purposes only.
+ */
+export declare const DEFAULT_BFV_PARAMS: BFVParams;
+/**
+ * Mock message for masking signature
+ */
+export declare const MESSAGE = "Vote for round 0";

package/dist/src/constants.js

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { ZKInputsGenerator } from '@crisp-e3/zk-inputs';
+export const CRISP_SERVER_TOKEN_TREE_ENDPOINT = 'state/token-holders';
+export const CRISP_SERVER_STATE_LITE_ENDPOINT = 'state/lite';
+/**
+ * This is the maximum value for a vote (Yes or No). This is 2^28
+ * The minimum degree that BFV should use is 56 (to accommodate both Yes and No votes)
+ * If you change this value, make sure to update the circuit too.
+ */
+export const MAXIMUM_VOTE_VALUE = 268435456n;
+/**
+ * Default BFV parameters for the CRISP ZK inputs generator.
+ * These are the parameters used for the default testing purposes only.
+ */
+export const DEFAULT_BFV_PARAMS = ZKInputsGenerator.withDefaults().getBFVParams();
+/**
+ * Mock message for masking signature
+ */
+export const MESSAGE = 'Vote for round 0';

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './token';
+export * from './state';
+export * from './constants';
+export * from './utils';
+export * from './vote';
+export * from './signature';
+export { VotingMode } from './types';
+export type { IRoundDetails, IRoundDetailsResponse, ITokenDetails, IMerkleProof, IVote, CRISPCircuitInputs, NoirSignatureInputs, } from './types';

package/dist/src/index.js

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+export * from './token';
+export * from './state';
+export * from './constants';
+export * from './utils';
+export * from './vote';
+export * from './signature';
+export { VotingMode } from './types';

package/dist/src/signature.d.ts

@@ -0,0 +1,8 @@
+import type { NoirSignatureInputs } from './types';
+/**
+ * Given a message and its signed version, extract the signature components
+ * @param message The original message
+ * @param signedMessage The signed message (signature)
+ * @returns The extracted signature components
+ */
+export declare const extractSignature: (message: string, signedMessage: `0x${string}`) => Promise<NoirSignatureInputs>;

package/dist/src/signature.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { hashMessage, hexToBytes, recoverPublicKey } from 'viem';
+/**
+ * Given a message and its signed version, extract the signature components
+ * @param message The original message
+ * @param signedMessage The signed message (signature)
+ * @returns The extracted signature components
+ */
+export const extractSignature = async (message, signedMessage) => {
+    const messageHash = hashMessage(message);
+    const messageBytes = hexToBytes(messageHash);
+    const publicKey = await recoverPublicKey({
+        hash: messageHash,
+        signature: signedMessage,
+    });
+    const publicKeyBytes = hexToBytes(publicKey);
+    const publicKeyX = publicKeyBytes.slice(1, 33);
+    const publicKeyY = publicKeyBytes.slice(33, 65);
+    // Extract r and s from signature (remove v)
+    const sigBytes = hexToBytes(signedMessage);
+    const r = sigBytes.slice(0, 32); // First 32 bytes
+    const s = sigBytes.slice(32, 64); // Next 32 bytes
+    const signatureBytes = new Uint8Array(64);
+    signatureBytes.set(r, 0);
+    signatureBytes.set(s, 32);
+    return {
+        hashed_message: messageBytes,
+        pub_key_x: publicKeyX,
+        pub_key_y: publicKeyY,
+        signature: signatureBytes,
+    };
+};

package/dist/src/state.d.ts

@@ -0,0 +1,12 @@
+import type { IRoundDetails, ITokenDetails } from './types';
+/**
+ * Get the details of a specific round
+ */
+export declare const getRoundDetails: (serverUrl: string, e3Id: number) => Promise<IRoundDetails>;
+/**
+ * Get the token address, balance threshold and snapshot block for a specific round
+ * @param serverUrl - The base URL of the CRISP server
+ * @param e3Id - The e3Id of the round
+ * @returns The token address, balance threshold and snapshot block
+ */
+export declare const getRoundTokenDetails: (serverUrl: string, e3Id: number) => Promise<ITokenDetails>;

package/dist/src/state.js

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { CRISP_SERVER_STATE_LITE_ENDPOINT } from './constants';
+/**
+ * Get the details of a specific round
+ */
+export const getRoundDetails = async (serverUrl, e3Id) => {
+    const response = await fetch(`${serverUrl}/${CRISP_SERVER_STATE_LITE_ENDPOINT}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ round_id: e3Id }),
+    });
+    const data = (await response.json());
+    return {
+        e3Id: BigInt(data.id),
+        tokenAddress: data.token_address,
+        balanceThreshold: BigInt(data.balance_threshold),
+        chainId: BigInt(data.chain_id),
+        enclaveAddress: data.enclave_address,
+        status: data.status,
+        voteCount: BigInt(data.vote_count),
+        startTime: BigInt(data.start_time),
+        duration: BigInt(data.duration),
+        expiration: BigInt(data.expiration),
+        startBlock: BigInt(data.start_block),
+        committeePublicKey: data.committee_public_key,
+        emojis: data.emojis,
+    };
+};
+/**
+ * Get the token address, balance threshold and snapshot block for a specific round
+ * @param serverUrl - The base URL of the CRISP server
+ * @param e3Id - The e3Id of the round
+ * @returns The token address, balance threshold and snapshot block
+ */
+export const getRoundTokenDetails = async (serverUrl, e3Id) => {
+    const roundDetails = await getRoundDetails(serverUrl, e3Id);
+    return {
+        tokenAddress: roundDetails.tokenAddress,
+        threshold: roundDetails.balanceThreshold,
+        snapshotBlock: roundDetails.startBlock,
+    };
+};

package/dist/src/token.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get the merkle tree data from the CRISP server
+ * @param serverUrl - The base URL of the CRISP server
+ * @param e3Id - The e3Id of the round
+ */
+export declare const getTreeData: (serverUrl: string, e3Id: number) => Promise<bigint[]>;
+/**
+ * Get the token balance at a specific block for a given address
+ * @param voterAddress - The address of the voter
+ * @param tokenAddress - The address of the token contract
+ * @param snapshotBlock - The block number at which to get the balance
+ * @param chainId - The chain ID of the network
+ * @returns The token balance as a bigint
+ */
+export declare const getBalanceAt: (voterAddress: string, tokenAddress: string, snapshotBlock: number, chainId: number) => Promise<bigint>;
+/**
+ * Get the total supply of a ERC20Votes Token at a specific block
+ * @param tokenAddress The token address to query
+ * @param snapshotBlock The block number at which to get the total supply
+ * @param chainId The chain ID of the network
+ * @returns The total supply as a bigint
+ */
+export declare const getTotalSupplyAt: (tokenAddress: string, snapshotBlock: number, chainId: number) => Promise<bigint>;

package/dist/src/token.js

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { CRISP_SERVER_TOKEN_TREE_ENDPOINT } from './constants';
+import ERC20Votes from './ERC20Votes.json';
+import { createPublicClient, http } from 'viem';
+import { localhost, sepolia } from 'viem/chains';
+/**
+ * Get the merkle tree data from the CRISP server
+ * @param serverUrl - The base URL of the CRISP server
+ * @param e3Id - The e3Id of the round
+ */
+export const getTreeData = async (serverUrl, e3Id) => {
+    const response = await fetch(`${serverUrl}/${CRISP_SERVER_TOKEN_TREE_ENDPOINT}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ round_id: e3Id }),
+    });
+    const hashes = (await response.json());
+    // Convert hex strings to BigInts
+    return hashes.map((hash) => {
+        // Ensure the hash is treated as a hex string
+        if (!hash.startsWith('0x')) {
+            return BigInt('0x' + hash);
+        }
+        return BigInt(hash);
+    });
+};
+/**
+ * Get the token balance at a specific block for a given address
+ * @param voterAddress - The address of the voter
+ * @param tokenAddress - The address of the token contract
+ * @param snapshotBlock - The block number at which to get the balance
+ * @param chainId - The chain ID of the network
+ * @returns The token balance as a bigint
+ */
+export const getBalanceAt = async (voterAddress, tokenAddress, snapshotBlock, chainId) => {
+    let chain;
+    switch (chainId) {
+        case 11155111:
+            chain = sepolia;
+            break;
+        case 31337:
+            chain = localhost;
+            break;
+        default:
+            throw new Error('Unsupported chainId');
+    }
+    const publicClient = createPublicClient({
+        transport: http(),
+        chain,
+    });
+    const balance = (await publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20Votes.abi,
+        functionName: 'getPastVotes',
+        args: [voterAddress, BigInt(snapshotBlock)],
+    }));
+    return balance;
+};
+/**
+ * Get the total supply of a ERC20Votes Token at a specific block
+ * @param tokenAddress The token address to query
+ * @param snapshotBlock The block number at which to get the total supply
+ * @param chainId The chain ID of the network
+ * @returns The total supply as a bigint
+ */
+export const getTotalSupplyAt = async (tokenAddress, snapshotBlock, chainId) => {
+    let chain;
+    switch (chainId) {
+        case 11155111:
+            chain = sepolia;
+            break;
+        case 31337:
+            chain = localhost;
+            break;
+        default:
+            throw new Error('Unsupported chainId');
+    }
+    const publicClient = createPublicClient({
+        transport: http(),
+        chain,
+    });
+    const totalSupply = (await publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20Votes.abi,
+        functionName: 'getPastTotalSupply',
+        args: [BigInt(snapshotBlock)],
+    }));
+    return totalSupply;
+};

package/dist/src/types.d.ts

@@ -0,0 +1,193 @@
+import type { LeanIMTMerkleProof } from '@zk-kit/lean-imt';
+/**
+ * Interface representing the details of a specific round returned by the CRISP server
+ */
+export interface IRoundDetailsResponse {
+    id: string;
+    chain_id: string;
+    enclave_address: string;
+    status: string;
+    vote_count: string;
+    start_time: string;
+    duration: string;
+    expiration: string;
+    start_block: string;
+    committee_public_key: string[];
+    emojis: [string, string];
+    token_address: string;
+    balance_threshold: string;
+}
+/**
+ * Interface representing the details of a specific round in a more convenient format
+ */
+export interface IRoundDetails {
+    e3Id: bigint;
+    chainId: bigint;
+    enclaveAddress: string;
+    status: string;
+    voteCount: bigint;
+    startTime: bigint;
+    duration: bigint;
+    expiration: bigint;
+    startBlock: bigint;
+    committeePublicKey: string[];
+    emojis: [string, string];
+    tokenAddress: string;
+    balanceThreshold: bigint;
+}
+/**
+ * Interface representing the token details required for participation in a round
+ */
+export interface ITokenDetails {
+    tokenAddress: string;
+    threshold: bigint;
+    snapshotBlock: bigint;
+}
+/**
+ * Interface representing a Merkle proof
+ */
+export interface IMerkleProof {
+    leaf: bigint;
+    index: number;
+    proof: LeanIMTMerkleProof<bigint>;
+    length: number;
+    indices: number[];
+}
+/**
+ * Enum representing the voting modes
+ */
+export declare enum VotingMode {
+    /**
+     *  Governance voting requires to spend all credits on one option
+        they cannot be split
+     */
+    GOVERNANCE = "GOVERNANCE"
+}
+/**
+ * Interface representing a vote with power for 'yes' and 'no'
+ */
+export interface IVote {
+    /**
+     * The voting power for 'yes' votes
+     */
+    yes: bigint;
+    /**
+     * The voting power for 'no' votes
+     */
+    no: bigint;
+}
+/**
+ * Interface representing a vector with coefficients
+ */
+export interface Polynomial {
+    coefficients: string[];
+}
+/**
+ * Interface representing cryptographic parameters
+ */
+export interface GrecoCryptographicParams {
+    q_mod_t: string;
+    qis: string[];
+    k0is: string[];
+}
+/**
+ * Interface representing Greco bounds
+ */
+export interface GrecoBoundParams {
+    e_bound: string;
+    u_bound: string;
+    k1_low_bound: string;
+    k1_up_bound: string;
+    p1_bounds: string[];
+    p2_bounds: string[];
+    pk_bounds: string[];
+    r1_low_bounds: string[];
+    r1_up_bounds: string[];
+    r2_bounds: string[];
+}
+/**
+ * Interface representing Greco parameters
+ */
+export interface GrecoParams {
+    crypto: GrecoCryptographicParams;
+    bounds: GrecoBoundParams;
+}
+/**
+ * The inputs required for the CRISP circuit
+ */
+export interface CRISPCircuitInputs {
+    prev_ct0is: Polynomial[];
+    prev_ct1is: Polynomial[];
+    sum_ct0is: Polynomial[];
+    sum_ct1is: Polynomial[];
+    sum_r0is: Polynomial[];
+    sum_r1is: Polynomial[];
+    params: GrecoParams;
+    ct0is: Polynomial[];
+    ct1is: Polynomial[];
+    pk0is: Polynomial[];
+    pk1is: Polynomial[];
+    r1is: Polynomial[];
+    r2is: Polynomial[];
+    p1is: Polynomial[];
+    p2is: Polynomial[];
+    u: Polynomial;
+    e0: Polynomial;
+    e1: Polynomial;
+    k1: Polynomial;
+    public_key_x: string[];
+    public_key_y: string[];
+    signature: string[];
+    hashed_message: string[];
+    merkle_root: string;
+    merkle_proof_length: string;
+    merkle_proof_indices: string[];
+    merkle_proof_siblings: string[];
+    slot_address: string;
+    balance: string;
+    is_first_vote: boolean;
+}
+/**
+ * Interface representing the BFV parameters
+ */
+export interface BFVParams {
+    degree: number;
+    plaintextModulus: bigint;
+    moduli: BigInt64Array;
+}
+/**
+ * Interface representing the inputs for Noir signature verification
+ */
+export interface NoirSignatureInputs {
+    /**
+     * X coordinate of the public key
+     */
+    pub_key_x: Uint8Array;
+    /**
+     * Y coordinate of the public key
+     */
+    pub_key_y: Uint8Array;
+    /**
+     * The signature to verify
+     */
+    signature: Uint8Array;
+    /**
+     * The hashed message that was signed
+     */
+    hashed_message: Uint8Array;
+}
+/**
+ * Parameters for encryptVoteAndGenerateCRISPInputs function
+ */
+export interface EncryptVoteAndGenerateCRISPInputsParams {
+    encodedVote: string[];
+    publicKey: Uint8Array;
+    previousCiphertext: Uint8Array;
+    signature: `0x${string}`;
+    message: string;
+    merkleData: IMerkleProof;
+    balance: bigint;
+    bfvParams?: BFVParams;
+    slotAddress: string;
+    isFirstVote: boolean;
+}

package/dist/src/types.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+/**
+ * Enum representing the voting modes
+ */
+export var VotingMode;
+(function (VotingMode) {
+    /**
+     *  Governance voting requires to spend all credits on one option
+        they cannot be split
+     */
+    VotingMode["GOVERNANCE"] = "GOVERNANCE";
+})(VotingMode || (VotingMode = {}));

package/dist/src/utils.d.ts

@@ -0,0 +1,30 @@
+import { LeanIMT } from '@zk-kit/lean-imt';
+import type { IMerkleProof } from './types';
+/**
+ * Hash a leaf node for the Merkle tree
+ * @param address The voter's address
+ * @param balance The voter's balance
+ * @returns The hashed leaf as a bigint
+ */
+export declare const hashLeaf: (address: string, balance: string) => bigint;
+/**
+ * Generate a new LeanIMT with the leaves provided
+ * @param leaves The leaves of the Merkle tree
+ * @returns the generated Merkle tree
+ */
+export declare const generateMerkleTree: (leaves: bigint[]) => LeanIMT;
+/**
+ * Generate a Merkle proof for a given address to prove inclusion in the voters' list
+ * @param threshold The minimum balance required to be eligible
+ * @param balance The voter's balance
+ * @param address The voter's address
+ * @param leaves The leaves of the Merkle tree
+ * @param maxDepth The maximum depth of the Merkle tree
+ */
+export declare const generateMerkleProof: (threshold: bigint, balance: bigint, address: string, leaves: bigint[], maxDepth: number) => IMerkleProof;
+/**
+ * Convert a number to its binary representation
+ * @param number The number to convert to binary
+ * @returns The binary representation of the number as a string
+ */
+export declare const toBinary: (number: bigint) => string;

package/dist/src/utils.js

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { poseidon2 } from 'poseidon-lite';
+import { LeanIMT } from '@zk-kit/lean-imt';
+/**
+ * Hash a leaf node for the Merkle tree
+ * @param address The voter's address
+ * @param balance The voter's balance
+ * @returns The hashed leaf as a bigint
+ */
+export const hashLeaf = (address, balance) => {
+    return poseidon2([address, balance]);
+};
+/**
+ * Generate a new LeanIMT with the leaves provided
+ * @param leaves The leaves of the Merkle tree
+ * @returns the generated Merkle tree
+ */
+export const generateMerkleTree = (leaves) => {
+    return new LeanIMT((a, b) => poseidon2([a, b]), leaves);
+};
+/**
+ * Generate a Merkle proof for a given address to prove inclusion in the voters' list
+ * @param threshold The minimum balance required to be eligible
+ * @param balance The voter's balance
+ * @param address The voter's address
+ * @param leaves The leaves of the Merkle tree
+ * @param maxDepth The maximum depth of the Merkle tree
+ */
+export const generateMerkleProof = (threshold, balance, address, leaves, maxDepth) => {
+    if (balance < threshold) {
+        throw new Error('Balance is below the threshold');
+    }
+    const leaf = hashLeaf(address, balance.toString());
+    const index = leaves.findIndex((l) => l === leaf);
+    if (index === -1) {
+        throw new Error('Leaf not found in the tree');
+    }
+    const tree = generateMerkleTree(leaves);
+    const proof = tree.generateProof(index);
+    // Pad siblings with zeros
+    const paddedSiblings = [...proof.siblings, ...Array(maxDepth - proof.siblings.length).fill(0n)];
+    // Pad indices with zeros
+    const indices = proof.siblings.map((_, i) => Number((BigInt(proof.index) >> BigInt(i)) & 1n));
+    const paddedIndices = [...indices, ...Array(maxDepth - indices.length).fill(0)];
+    return {
+        leaf,
+        index,
+        proof: {
+            ...proof,
+            siblings: paddedSiblings,
+        },
+        // Original length before padding
+        length: proof.siblings.length,
+        indices: paddedIndices,
+    };
+};
+/**
+ * Convert a number to its binary representation
+ * @param number The number to convert to binary
+ * @returns The binary representation of the number as a string
+ */
+export const toBinary = (number) => {
+    if (number < 0) {
+        throw new Error('Value cannot be negative');
+    }
+    return number.toString(2);
+};

package/dist/src/vote.d.ts

@@ -0,0 +1,71 @@
+import { BFVParams, type CRISPCircuitInputs, type EncryptVoteAndGenerateCRISPInputsParams, type IVote, VotingMode } from './types';
+import { type ProofData } from '@aztec/bb.js';
+/**
+ * This utility function calculates the first valid index for vote options
+ * based on the total voting power and degree.
+ * @dev This is needed to calculate the decoded plaintext
+ * @dev Also, we will need to check in the circuit that anything within these indices is
+ * either 0 or 1.
+ * @param totalVotingPower The maximum vote amount (if a single voter had all of the power)
+ * @param degree The degree of the polynomial
+ */
+export declare const calculateValidIndicesForPlaintext: (totalVotingPower: bigint, degree: number) => {
+    yesIndex: number;
+    noIndex: number;
+};
+/**
+ * Encode a vote based on the voting mode
+ * @param vote The vote to encode
+ * @param votingMode The voting mode to use for encoding
+ * @param votingPower The voting power of the voter
+ * @param bfvParams The BFV parameters to use for encoding
+ * @returns The encoded vote as a string
+ */
+export declare const encodeVote: (vote: IVote, votingMode: VotingMode, votingPower: bigint, bfvParams?: BFVParams) => string[];
+/**
+ * Given an encoded tally, decode it into its decimal representation
+ * @param tally The encoded tally to decode
+ * @param votingMode The voting mode
+ */
+export declare const decodeTally: (tally: string[], votingMode: VotingMode) => IVote;
+/**
+ * Validate whether a vote is valid for a given voting mode
+ * @param votingMode The voting mode to validate against
+ * @param vote The vote to validate
+ * @param votingPower The voting power of the voter
+ */
+export declare const validateVote: (votingMode: VotingMode, vote: IVote, votingPower: bigint) => void;
+/**
+ * This is a wrapper around enclave-e3/sdk encryption functions as CRISP circuit will require some more
+ * input values which generic Greco do not need.
+ * @param encodedVote The encoded vote as string array
+ * @param publicKey The public key to use for encryption
+ * @param previousCiphertext The previous ciphertext to use for addition operation
+ * @param bfvParams The BFV parameters to use for encryption
+ * @param merkleData The merkle proof data
+ * @param message The message that was signed
+ * @param signature The signature of the message
+ * @param balance The voter's balance
+ * @param slotAddress The voter's slot address
+ * @param isFirstVote Whether this is the first vote for this slot
+ * @returns The CRISP circuit inputs
+ */
+export declare const encryptVoteAndGenerateCRISPInputs: ({ encodedVote, publicKey, previousCiphertext, bfvParams, merkleData, message, signature, balance, slotAddress, isFirstVote, }: EncryptVoteAndGenerateCRISPInputsParams) => Promise<CRISPCircuitInputs>;
+/**
+ * A function to generate the data required to mask a vote
+ * @param voter The voter's address
+ * @param publicKey The voter's public key
+ * @param previousCiphertext The previous ciphertext
+ * @param bfvParams The BFV parameters
+ * @param merkleRoot The merkle root of the census tree
+ * @param slotAddress The voter's slot address
+ * @param isFirstVote Whether this is the first vote for this slot
+ * @returns The CRISP circuit inputs for a mask vote
+ */
+export declare const generateMaskVote: (publicKey: Uint8Array, previousCiphertext: Uint8Array, bfvParams: BFVParams | undefined, merkleRoot: bigint, slotAddress: string, isFirstVote: boolean) => Promise<CRISPCircuitInputs>;
+export declare const generateProof: (crispInputs: CRISPCircuitInputs) => Promise<ProofData>;
+export declare const generateProofWithReturnValue: (crispInputs: CRISPCircuitInputs) => Promise<{
+    returnValue: unknown;
+    proof: ProofData;
+}>;
+export declare const verifyProof: (proof: ProofData) => Promise<boolean>;