@0xbow/privacy-pools-core-sdk 0.1.5

package/dist/esm/index.mjs

@@ -0,0 +1,4 @@
+export { o as BlockchainProvider, u as CircuitName, p as Circuits, C as CommitmentService, t as ContractError, q as ContractInteractionsService, E as ErrorCode, I as InvalidRpcUrl, P as PrivacyPoolSDK, r as ProofError, S as SDKError, W as WithdrawalService, l as bigintToHash, m as bigintToHex, n as calculateContext, k as generateMerkleProof, f as generateSecrets, j as getCommitment, h as hashPrecommitment } from './index-DAWUECi8.js';
+import 'buffer';
+import 'assert';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/index.d.mts

@@ -0,0 +1,666 @@
+import { Groth16Proof, PublicSignals } from 'snarkjs';
+import { Address, Hex, Chain } from 'viem';
+export { Address } from 'viem';
+import { LeanIMTMerkleProof } from '@zk-kit/lean-imt';
+export { LeanIMTMerkleProof } from '@zk-kit/lean-imt';
+
+/**
+ * Represents a hash value in the system.
+ * This is a branded type to ensure type safety.
+ */
+type Hash = bigint & {
+    readonly __brand: unique symbol;
+};
+/**
+ * Represents a secret value in the system.
+ * This is a branded type to ensure type safety.
+ */
+type Secret = bigint & {
+    readonly __brand: unique symbol;
+};
+/**
+ * Represents a precommitment structure containing the hash, nullifier, and secret.
+ * All hashes are computed using Poseidon.
+ */
+interface Precommitment {
+    readonly hash: Hash;
+    readonly nullifier: Secret;
+    readonly secret: Secret;
+}
+/**
+ * Represents the preimage of a commitment containing the value, label, and precommitment.
+ */
+interface CommitmentPreimage {
+    readonly value: bigint;
+    readonly label: bigint;
+    readonly precommitment: Precommitment;
+}
+/**
+ * Represents a complete commitment structure.
+ * All hashes are computed using Poseidon.
+ */
+interface Commitment {
+    readonly hash: Hash;
+    readonly nullifierHash: Hash;
+    readonly preimage: CommitmentPreimage;
+}
+/**
+ * Represents the result of a commitment proof operation.
+ */
+interface CommitmentProof {
+    readonly proof: Groth16Proof;
+    readonly publicSignals: PublicSignals;
+}
+
+/**
+ * Represents a withdrawal request in the system.
+ */
+interface Withdrawal {
+    readonly processooor: Address;
+    readonly data: Hex;
+}
+interface WithdrawalProof {
+    readonly proof: Groth16Proof;
+    readonly publicSignals: PublicSignals;
+}
+/**
+ * Input parameters required for withdrawal proof generation.
+ */
+interface WithdrawalProofInput {
+    readonly context: bigint;
+    readonly withdrawalAmount: bigint;
+    readonly stateMerkleProof: LeanIMTMerkleProof<bigint>;
+    readonly aspMerkleProof: LeanIMTMerkleProof<bigint>;
+    readonly stateRoot: Hash;
+    readonly stateTreeDepth: bigint;
+    readonly aspRoot: Hash;
+    readonly aspTreeDepth: bigint;
+    readonly newSecret: Secret;
+    readonly newNullifier: Secret;
+}
+
+/**
+ * Generates random nullifier and secret.
+ *
+ * @returns {{ nullifier: Secret, secret: Secret }} Randomly generated secrets.
+ */
+declare function generateSecrets(): {
+    nullifier: Secret;
+    secret: Secret;
+};
+/**
+ * Computes a Poseidon hash for the given nullifier and secret.
+ *
+ * @param {Secret} nullifier - The nullifier to hash.
+ * @param {Secret} secret - The secret to hash.
+ * @returns {Hash} The Poseidon hash.
+ */
+declare function hashPrecommitment(nullifier: Secret, secret: Secret): Hash;
+/**
+ * Generates a commitment using the given parameters.
+ *
+ * @param {bigint} value - The value associated with the commitment.
+ * @param {bigint} label - The label used for the commitment.
+ * @param {Secret} nullifier - The nullifier used in the precommitment.
+ * @param {Secret} secret - The secret used in the precommitment.
+ * @returns {Commitment} The generated commitment object.
+ */
+declare function getCommitment(value: bigint, label: bigint, nullifier: Secret, secret: Secret): Commitment;
+/**
+ * Generates a Merkle inclusion proof for a given leaf in a set of leaves.
+ *
+ * @param {bigint[]} leaves - Array of leaves for the Lean Incremental Merkle tree.
+ * @param {bigint} leaf - The specific leaf to generate the inclusion proof for.
+ * @returns {LeanIMTMerkleProof<bigint>} A lean incremental Merkle tree inclusion proof.
+ * @throws {Error} If the leaf is not found in the leaves array.
+ */
+declare function generateMerkleProof(leaves: bigint[], leaf: bigint): LeanIMTMerkleProof<bigint>;
+declare function bigintToHash(value: bigint): Hash;
+declare function bigintToHex(num: bigint | string | undefined): Hex;
+/**
+ * Calculates the context hash for a withdrawal.
+ */
+declare function calculateContext(withdrawal: Withdrawal, scope: Hash): string;
+
+declare class InvalidRpcUrl extends Error {
+    constructor(url: string);
+}
+
+/**
+ * Represents an interface for a blockchain provider.
+ */
+interface IBlockchainProvider {
+    /**
+     * Retrieves the balance of the specified address.
+     * @param {Address} address The address for which to retrieve the balance.
+     * @returns {Promise<bigint>} A Promise that resolves to the balance of the address.
+     */
+    getBalance(address: Address): Promise<bigint>;
+}
+
+declare class BlockchainProvider implements IBlockchainProvider {
+    private client;
+    constructor(rpcUrl: string);
+    /** @inheritdoc */
+    getBalance(address: Address): Promise<bigint>;
+}
+
+/**
+ * Enum representing available versions of circuit artifacts.
+ */
+declare enum Version {
+    /**
+     * The latest version of the circuit artifacts.
+     */
+    Latest = "latest"
+}
+/**
+ * Type representing a version string, which is a string literal derived from the Version enum.
+ */
+type VersionString = `${Version}`;
+/**
+ * Enum representing the names of available circuits.
+ */
+declare enum CircuitName$1 {
+    /**
+     * Circuit for commitments.
+     */
+    Commitment = "commitment",
+    /**
+     * Circuit for Merkle tree operations.
+     */
+    MerkleTree = "merkleTree",
+    /**
+     * Circuit for withdrawal operations.
+     */
+    Withdraw = "withdraw"
+}
+/**
+ * Type representing a circuit name string, which is a string literal derived from the CircuitName enum.
+ */
+type CircuitNameString = `${CircuitName$1}`;
+/**
+ * Interface representing the artifacts associated with a circuit.
+ */
+interface CircuitArtifacts {
+    /**
+     * The precompiled wasm file for the circuit.
+     * @type {Uint8Array}
+     */
+    wasm: Uint8Array;
+    /**
+     * The verification key for the circuit.
+     * @type {Uint8Array}
+     */
+    vkey: Uint8Array;
+    /**
+     * The proving key for the circuit.
+     * @type {Uint8Array}
+     */
+    zkey: Uint8Array;
+}
+/**
+ * Type representing the mapping of circuit name strings to their associated circuit artifacts.
+ */
+type Binaries = {
+    [key in CircuitNameString]: CircuitArtifacts;
+};
+/**
+ * Interface defining the methods required for managing circuits and their artifacts.
+ */
+interface CircuitsInterface$1 {
+    /**
+     * Downloads all artifacts for the specified version of circuits.
+     * @param {VersionString} version - The version of the artifacts to download.
+     * @returns {Promise<Binaries>} A promise that resolves to the binaries containing all circuit artifacts.
+     * @async
+     */
+    downloadArtifacts(version: VersionString): Promise<Binaries>;
+    /**
+     * Initializes the artifacts for the specified version of circuits.
+     * @param {VersionString} version - The version of the artifacts to initialize.
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     * @async
+     */
+    initArtifacts(version: VersionString): Promise<void>;
+    /**
+     * Retrieves the verification key for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version] - The version of the artifacts (defaults to the latest).
+     * @returns {Promise<Uint8Array>} A promise that resolves to the verification key.
+     * @async
+     */
+    getVerificationKey(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+    /**
+     * Retrieves the proving key for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version] - The version of the artifacts (defaults to the latest).
+     * @returns {Promise<Uint8Array>} A promise that resolves to the proving key.
+     * @async
+     */
+    getProvingKey(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+    /**
+     * Retrieves the wasm file for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version] - The version of the artifacts (defaults to the latest).
+     * @returns {Promise<Uint8Array>} A promise that resolves to the wasm file.
+     * @async
+     */
+    getWasm(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+}
+
+/**
+ * Class representing circuit management and artifact handling.
+ * Implements the CircuitsInterface.
+ */
+declare class Circuits implements CircuitsInterface$1 {
+    /**
+     * Indicates whether the circuits have been initialized.
+     * @type {boolean}
+     * @protected
+     */
+    protected initialized: boolean;
+    /**
+     * The version of the circuit artifacts being used.
+     * @type {VersionString}
+     * @protected
+     */
+    protected version: VersionString;
+    /**
+     * The binaries containing circuit artifacts such as wasm, vkey, and zkey files.
+     * @type {Binaries}
+     * @protected
+     */
+    protected binaries: Binaries;
+    /**
+     * The base URL for fetching circuit artifacts.
+     * @type {string}
+     * @protected
+     */
+    protected baseUrl: string;
+    /**
+     * Determines whether the environment is a browser.
+     * @returns {boolean} True if running in a browser environment, false otherwise.
+     * @protected
+     */
+    _browser(): boolean;
+    /**
+     * Initializes the circuit manager with binaries and a version.
+     * @param {Binaries} binaries - The binaries containing circuit artifacts.
+     * @param {VersionString} version - The version of the circuit artifacts.
+     * @protected
+     */
+    protected _initialize(binaries: Binaries, version: VersionString): void;
+    /**
+     * Handles initialization of circuit artifacts, fetching them if necessary.
+     * @param {VersionString} [version=Version.latest] - The version of the circuit artifacts.
+     * @throws {CircuitInitialization} If an error occurs during initialization.
+     * @protected
+     * @async
+     */
+    protected _handleInitialization(version?: VersionString): Promise<void>;
+    /**
+     * Fetches a versioned artifact from a given path.
+     * @param {string} artifactPath - The path to the artifact.
+     * @param {VersionString} version - The version of the artifact.
+     * @returns {Promise<Uint8Array>} A promise that resolves to the artifact as a Uint8Array.
+     * @throws {FetchArtifact} If the artifact cannot be fetched.
+     * @protected
+     * @async
+     */
+    _fetchVersionedArtifact(artifactPath: string): Promise<Uint8Array>;
+    /**
+     * Downloads and returns the circuit artifacts for a specific circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @returns {Promise<CircuitArtifacts>} A promise that resolves to the circuit artifacts.
+     * @protected
+     * @async
+     */
+    _downloadCircuitArtifacts(circuitName: CircuitNameString): Promise<CircuitArtifacts>;
+    /**
+     * Downloads all circuit artifacts for the specified version.
+     * @param {VersionString} version - The version of the artifacts.
+     * @returns {Promise<Binaries>} A promise that resolves to the binaries containing all circuit artifacts.
+     * @async
+     */
+    downloadArtifacts(version: VersionString): Promise<Binaries>;
+    /**
+     * Initializes the circuit artifacts for the specified version.
+     * @param {VersionString} version - The version of the artifacts.
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     * @async
+     */
+    initArtifacts(version: VersionString): Promise<void>;
+    /**
+     * Retrieves the verification key for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version=Version.latest] - The version of the artifacts.
+     * @returns {Promise<Uint8Array>} A promise that resolves to the verification key.
+     * @async
+     */
+    getVerificationKey(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+    /**
+     * Retrieves the proving key for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version=Version.latest] - The version of the artifacts.
+     * @returns {Promise<Uint8Array>} A promise that resolves to the proving key.
+     * @async
+     */
+    getProvingKey(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+    /**
+     * Retrieves the wasm file for a specified circuit.
+     * @param {CircuitNameString} circuitName - The name of the circuit.
+     * @param {VersionString} [version=Version.latest] - The version of the artifacts.
+     * @returns {Promise<Uint8Array>} A promise that resolves to the wasm file.
+     * @async
+     */
+    getWasm(circuitName: CircuitNameString, version?: VersionString): Promise<Uint8Array>;
+}
+
+interface TransactionResponse {
+    hash: string;
+    wait: () => Promise<void>;
+}
+interface ContractInteractions {
+    depositERC20(asset: Address, amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    depositETH(amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    withdraw(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    relay(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    ragequit(commitmentProof: CommitmentProof, privacyPoolAddress: Address): Promise<TransactionResponse>;
+    getScope(privacyPoolAddress: Address): Promise<bigint>;
+    getStateRoot(privacyPoolAddress: Address): Promise<bigint>;
+    getStateSize(privacyPoolAddress: Address): Promise<bigint>;
+    getScopeData(scope: bigint): Promise<{
+        poolAddress: Address | null;
+        assetAddress: Address | null;
+    }>;
+    approveERC20(spenderAddress: Address, tokenAddress: Address, amount: bigint): Promise<TransactionResponse>;
+}
+
+declare class ContractInteractionsService implements ContractInteractions {
+    private publicClient;
+    private walletClient;
+    private entrypointAddress;
+    private account;
+    /**
+     * Initializes the contract interactions service.
+     *
+     * @param rpcUrl - The RPC endpoint URL for the blockchain network.
+     * @param chain - The blockchain network configuration.
+     * @param entrypointAddress - The address of the entrypoint contract.
+     * @param accountPrivateKey - The private key used for signing transactions.
+     */
+    constructor(rpcUrl: string, chain: Chain, entrypointAddress: Address, accountPrivateKey: Hex);
+    /**
+     * Deposits ERC20 tokens into the privacy pool.
+     *
+     * @param asset - The address of the ERC20 token.
+     * @param amount - The amount of tokens to deposit.
+     * @param precommitment - The precommitment value.
+     * @returns Transaction response containing the transaction hash.
+     */
+    depositERC20(asset: Address, amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    /**
+     * Deposits ETH into the privacy pool.
+     *
+     * @param amount - The amount of ETH to deposit.
+     * @param precommitment - The precommitment value.
+     * @returns Transaction response containing the transaction hash.
+     */
+    depositETH(amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    /**
+     * Withdraws funds from the privacy pool.
+     *
+     * @param withdrawal - The withdrawal object containing recipient details and amount.
+     * @param withdrawalProof - The cryptographic proof verifying the withdrawal.
+     * @returns Transaction response containing the transaction hash.
+     */
+    withdraw(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    /**
+     * Relays a withdrawal transaction to the entrypoint contract.
+     * This function is used to facilitate relayer transactions.
+     *
+     * @param withdrawal - The withdrawal data structure.
+     * @param withdrawalProof - The cryptographic proof required for withdrawal.
+     * @returns Transaction response containing hash and wait function.
+     */
+    relay(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    /**
+     * Executes a ragequit operation, allowing a user to exit the pool
+     * by nullifying their commitment and proving their withdrawal.
+     *
+     * @param commitmentProof - The cryptographic proof of the commitment.
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns Transaction response containing hash and wait function.
+     */
+    ragequit(commitmentProof: CommitmentProof, privacyPoolAddress: Address): Promise<TransactionResponse>;
+    /**
+     * Retrieves the scope identifier of a given privacy pool.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The scope identifier as a bigint.
+     */
+    getScope(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves the latest state root of the privacy pool from the entrypoint contract.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The latest state root as a bigint.
+     */
+    getStateRoot(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves the current state size of the privacy pool.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The size of the state tree as a bigint.
+     */
+    getStateSize(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves data about a specific scope, including the associated privacy pool
+     * and the asset used in that pool.
+     *
+     * @param scope - The scope identifier to look up.
+     * @returns An object containing the privacy pool address and asset address.
+     * @throws ContractError if the scope does not exist.
+     */
+    getScopeData(scope: bigint): Promise<{
+        poolAddress: Address;
+        assetAddress: Address;
+    }>;
+    /**
+     * Approves the entrypoint contract to spend a specified amount of ERC20 tokens.
+     *
+     * @param spenderAddress - The address of the entity that will be approved to spend tokens.
+     * @param tokenAddress - The address of the ERC20 token contract.
+     * @param amount - The amount of tokens to approve.
+     * @returns Transaction response containing hash and wait function.
+     */
+    approveERC20(spenderAddress: Address, tokenAddress: Address, amount: bigint): Promise<TransactionResponse>;
+    private formatProof;
+    private executeTransaction;
+}
+
+/**
+ * Available circuit types in the system.
+ */
+declare enum CircuitName {
+    Commitment = "commitment",
+    Withdraw = "withdraw"
+}
+/**
+ * Type for circuit input signals.
+ */
+type CircuitSignals = {
+    [key: string]: bigint | bigint[] | string;
+};
+/**
+ * Interface for accessing circuit-related resources.
+ */
+interface CircuitsInterface {
+    /**
+     * Gets the WASM binary for a circuit.
+     */
+    getWasm(name: CircuitName): Promise<Uint8Array>;
+    /**
+     * Gets the proving key for a circuit.
+     */
+    getProvingKey(name: CircuitName): Promise<Uint8Array>;
+    /**
+     * Gets the verification key for a circuit.
+     */
+    getVerificationKey(name: CircuitName): Promise<Uint8Array>;
+}
+
+/**
+ * Main SDK class providing access to all privacy pool functionality.
+ * Uses Poseidon hash for all commitment operations.
+ */
+declare class PrivacyPoolSDK {
+    private readonly commitmentService;
+    private readonly withdrawalService;
+    constructor(circuits: CircuitsInterface);
+    createContractInstance(rpcUrl: string, chain: Chain, entrypointAddress: Address, privateKey: Hex): ContractInteractionsService;
+    /**
+     * Generates a commitment proof.
+     *
+     * @param value - Value to commit
+     * @param label - Label for the commitment
+     * @param nullifier - Nullifier for the commitment
+     * @param secret - Secret for the commitment
+     */
+    proveCommitment(value: bigint, label: bigint, nullifier: bigint, secret: bigint): Promise<CommitmentProof>;
+    /**
+     * Verifies a commitment proof.
+     *
+     * @param proof - The proof to verify
+     */
+    verifyCommitment(proof: CommitmentProof): Promise<boolean>;
+    /**
+     * Generates a withdrawal proof.
+     *
+     * @param commitment - Commitment to withdraw
+     * @param input - Input parameters for the withdrawal
+     * @param withdrawal - Withdrawal details
+     */
+    proveWithdrawal(commitment: Commitment, input: WithdrawalProofInput): Promise<WithdrawalProof>;
+    /**
+     * Verifies a withdrawal proof.
+     *
+     * @param withdrawalProof - The withdrawal payload to verify
+     */
+    verifyWithdrawal(withdrawalProof: WithdrawalProof): Promise<boolean>;
+}
+
+/**
+ * Unified error codes for the SDK.
+ */
+declare enum ErrorCode {
+    UNKNOWN = "UNKNOWN",
+    INVALID_INPUT = "INVALID_INPUT",
+    OPERATION_FAILED = "OPERATION_FAILED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    PROOF_GENERATION_FAILED = "PROOF_GENERATION_FAILED",
+    PROOF_VERIFICATION_FAILED = "PROOF_VERIFICATION_FAILED",
+    INVALID_PROOF = "INVALID_PROOF",
+    INVALID_PUBLIC_SIGNALS = "INVALID_PUBLIC_SIGNALS",
+    CIRCUIT_ERROR = "CIRCUIT_ERROR",
+    CONTRACT_ERROR = "CONTRACT_ERROR",
+    CRYPTO_ERROR = "CRYPTO_ERROR",
+    MERKLE_ERROR = "MERKLE_ERROR"
+}
+/**
+ * Base error class for the SDK.
+ * All other error classes should extend this.
+ */
+declare class SDKError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown> | undefined);
+    /**
+     * Creates a JSON representation of the error.
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Specialized error class for proof-related operations.
+ */
+declare class ProofError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    /**
+     * Creates an error for proof generation failures.
+     */
+    static generationFailed(details?: Record<string, unknown>): ProofError;
+    /**
+     * Creates an error for proof verification failures.
+     */
+    static verificationFailed(details?: Record<string, unknown>): ProofError;
+    /**
+     * Creates an error for invalid proof format.
+     */
+    static invalidProof(details?: Record<string, unknown>): ProofError;
+}
+declare class ContractError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    static scopeNotFound(scope: bigint): ContractError;
+}
+
+/**
+ * Service responsible for handling commitment-related operations.
+ * All hash operations use Poseidon for ZK-friendly hashing.
+ */
+declare class CommitmentService {
+    private readonly circuits;
+    constructor(circuits: CircuitsInterface);
+    /**
+     * Generates a zero-knowledge proof for a commitment using Poseidon hash.
+     *
+     * @param value - The value being committed to
+     * @param label - Label associated with the commitment
+     * @param nullifier - Unique nullifier for the commitment
+     * @param secret - Secret key for the commitment
+     * @returns Promise resolving to proof and public signals
+     * @throws {ProofError} If proof generation fails
+     */
+    proveCommitment(value: bigint, label: bigint, nullifier: bigint, secret: bigint): Promise<CommitmentProof>;
+    /**
+     * Verifies a commitment proof.
+     *
+     * @param proof - The commitment proof to verify
+     * @param publicSignals - Public signals associated with the proof
+     * @returns Promise resolving to boolean indicating proof validity
+     * @throws {ProofError} If verification fails
+     */
+    verifyCommitment({ proof, publicSignals, }: CommitmentProof): Promise<boolean>;
+}
+
+/**
+ * Service responsible for handling withdrawal-related operations.
+ */
+declare class WithdrawalService {
+    private readonly circuits;
+    constructor(circuits: CircuitsInterface);
+    /**
+     * Generates a withdrawal proof.
+     *
+     * @param commitment - Commitment to withdraw
+     * @param input - Input parameters for the withdrawal
+     * @param withdrawal - Withdrawal details
+     * @returns Promise resolving to withdrawal payload
+     * @throws {ProofError} If proof generation fails
+     */
+    proveWithdrawal(commitment: Commitment, input: WithdrawalProofInput): Promise<WithdrawalProof>;
+    /**
+     * Verifies a withdrawal proof.
+     *
+     * @param withdrawalPayload - The withdrawal payload to verify
+     * @returns Promise resolving to boolean indicating proof validity
+     * @throws {ProofError} If verification fails
+     */
+    verifyWithdrawal(withdrawalPayload: WithdrawalProof): Promise<boolean>;
+    /**
+     * Prepares input signals for the withdrawal circuit.
+     */
+    private prepareInputSignals;
+}
+
+export { BlockchainProvider, CircuitName, type CircuitSignals, Circuits, type CircuitsInterface, type Commitment, type CommitmentPreimage, type CommitmentProof, CommitmentService, ContractError, ContractInteractionsService, ErrorCode, type Hash, type IBlockchainProvider, InvalidRpcUrl, type Precommitment, PrivacyPoolSDK, ProofError, SDKError, type Secret, type Withdrawal, type WithdrawalProof, type WithdrawalProofInput, WithdrawalService, bigintToHash, bigintToHex, calculateContext, generateMerkleProof, generateSecrets, getCommitment, hashPrecommitment };