@vocdoni/davinci-sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1388 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { ContractTransactionResponse, ContractRunner, Signer, Wallet } from 'ethers';
+import * as _vocdoni_davinci_contracts_dist_src_ProcessRegistry from '@vocdoni/davinci-contracts/dist/src/ProcessRegistry';
+
+type AnyJson = boolean | number | string | null | JsonArray | JsonMap | any;
+interface JsonMap {
+    [key: string]: AnyJson;
+}
+interface JsonArray extends Array<AnyJson> {
+}
+type CustomMeta = AnyJson | JsonArray | JsonMap;
+type MultiLanguage<T> = {
+    default: T;
+    [lang: string]: T;
+};
+interface IChoice {
+    title: MultiLanguage<string>;
+    value: number;
+    meta?: CustomMeta;
+    results?: string;
+    answer?: number;
+}
+type Choice = Pick<IChoice, 'title' | 'value' | 'meta'>;
+interface IQuestion {
+    title: MultiLanguage<string>;
+    description?: MultiLanguage<string>;
+    numAbstains?: string;
+    meta?: CustomMeta;
+    choices: Array<IChoice>;
+}
+type Question = Pick<IQuestion, 'title' | 'description' | 'choices' | 'meta'>;
+declare enum ElectionResultsTypeNames {
+    SINGLE_CHOICE_MULTIQUESTION = "single-choice-multiquestion",
+    MULTIPLE_CHOICE = "multiple-choice",
+    BUDGET = "budget-based",
+    APPROVAL = "approval",
+    QUADRATIC = "quadratic"
+}
+interface AbstainProperties {
+    canAbstain: boolean;
+    abstainValues: Array<string>;
+}
+interface ChoiceProperties {
+    repeatChoice: boolean;
+    numChoices: {
+        min: number;
+        max: number;
+    };
+}
+interface BudgetProperties {
+    useCensusWeightAsBudget: boolean;
+    maxBudget: number;
+    minStep: number;
+    forceFullBudget: boolean;
+}
+interface ApprovalProperties {
+    rejectValue: number;
+    acceptValue: number;
+}
+interface QuadraticProperties extends BudgetProperties {
+    quadraticCost: number;
+}
+type ElectionResultsType = {
+    name: ElectionResultsTypeNames.SINGLE_CHOICE_MULTIQUESTION;
+    properties: Record<string, never>;
+} | {
+    name: ElectionResultsTypeNames.MULTIPLE_CHOICE;
+    properties: AbstainProperties & ChoiceProperties;
+} | {
+    name: ElectionResultsTypeNames.BUDGET;
+    properties: BudgetProperties;
+} | {
+    name: ElectionResultsTypeNames.APPROVAL;
+    properties: ApprovalProperties;
+} | {
+    name: ElectionResultsTypeNames.QUADRATIC;
+    properties: QuadraticProperties;
+};
+type ProtocolVersion = '1.1' | '1.2';
+interface ElectionMetadata {
+    version: ProtocolVersion;
+    title: MultiLanguage<string>;
+    description: MultiLanguage<string>;
+    media: {
+        header: string;
+        logo: string;
+    };
+    meta?: {
+        [key: string]: any;
+    };
+    questions: Array<IQuestion>;
+    type: ElectionResultsType;
+}
+declare const ElectionMetadataTemplate: ElectionMetadata;
+declare const getElectionMetadataTemplate: () => ElectionMetadata;
+
+interface ApiError {
+    error: string;
+    code: number;
+}
+declare class BaseService {
+    protected axios: AxiosInstance;
+    constructor(baseURL: string, config?: AxiosRequestConfig);
+    protected request<T>(config: AxiosRequestConfig): Promise<T>;
+}
+
+/**
+ * Census origin types
+ */
+declare enum CensusOrigin {
+    /** Indicates that the census is derived from a Merkle Tree structure */
+    CensusOriginMerkleTree = 1,
+    /** Indicates that the census is provided by a Credential Service Provider (CSP) */
+    CensusOriginCSP = 2
+}
+interface CensusParticipant {
+    key: string;
+    weight?: string;
+}
+interface BaseCensusProof {
+    /** The Merkle root (hex-prefixed). */
+    root: string;
+    /** The voter's address (hex-prefixed). */
+    address: string;
+    /** The weight as a decimal string. */
+    weight: string;
+    /** Census origin type: CensusOriginMerkleTree for merkle proofs, CensusOriginCSP for csp proofs */
+    censusOrigin: CensusOrigin;
+}
+interface MerkleCensusProof extends BaseCensusProof {
+    censusOrigin: CensusOrigin.CensusOriginMerkleTree;
+    /** The leaf value (hex-prefixed weight). */
+    value: string;
+    /** The serialized sibling path (hex-prefixed). */
+    siblings: string;
+}
+interface CSPCensusProof extends BaseCensusProof {
+    censusOrigin: CensusOrigin.CensusOriginCSP;
+    /** The process id signed with the address (hex-prefixed). */
+    processId: string;
+    /** The public key of the csp (hex-prefixed). */
+    publicKey: string;
+    /** The signature that proves that the voter is in the census (hex-prefixed). */
+    signature: string;
+}
+type CensusProof = MerkleCensusProof | CSPCensusProof;
+/**
+ * Provider function for Merkle census proofs
+ */
+type MerkleCensusProofProvider = (args: {
+    censusRoot: string;
+    address: string;
+}) => Promise<MerkleCensusProof>;
+/**
+ * Provider function for CSP census proofs
+ */
+type CSPCensusProofProvider = (args: {
+    processId: string;
+    address: string;
+}) => Promise<CSPCensusProof>;
+/**
+ * Configuration for census proof providers
+ */
+interface CensusProviders {
+    /** Optional override for Merkle census proof fetching */
+    merkle?: MerkleCensusProofProvider;
+    /** Required provider for CSP census proof generation */
+    csp?: CSPCensusProofProvider;
+}
+interface PublishCensusResponse {
+    /** The Merkle root of the published census (hex-prefixed). */
+    root: string;
+    /** The number of participants in the census. */
+    participantCount: number;
+    /** ISO timestamp when the working census was created. */
+    createdAt: string;
+    /** ISO timestamp when the census was published. */
+    publishedAt: string;
+    /** The constructed URI for accessing the census */
+    uri: string;
+}
+interface Snapshot {
+    /** ISO timestamp of the snapshot date. */
+    snapshotDate: string;
+    /** The Merkle root of the census (hex-prefixed). */
+    censusRoot: string;
+    /** The number of participants in the census. */
+    participantCount: number;
+    /** Minimum balance filter applied. */
+    minBalance: number;
+    /** User-defined query name. */
+    queryName: string;
+    /** ISO timestamp when the snapshot was created. */
+    createdAt: string;
+    /** Type of query executed (optional). */
+    queryType?: string;
+    /** Token decimals (optional). */
+    decimals?: number;
+    /** Query execution period (optional). */
+    period?: string;
+    /** Query parameters (optional). */
+    parameters?: Record<string, any>;
+    /** Weight configuration (optional). */
+    weightConfig?: {
+        strategy: string;
+        targetMinWeight: number;
+        maxWeight: number;
+    };
+}
+interface SnapshotsResponse {
+    /** Array of snapshots. */
+    snapshots: Snapshot[];
+    /** Total number of snapshots. */
+    total: number;
+    /** Current page number. */
+    page: number;
+    /** Number of items per page. */
+    pageSize: number;
+    /** Whether there is a next page. */
+    hasNext: boolean;
+    /** Whether there is a previous page. */
+    hasPrev: boolean;
+}
+interface SnapshotsQueryParams {
+    /** Page number (default: 1). */
+    page?: number;
+    /** Items per page (default: 20, max: 100). */
+    pageSize?: number;
+    /** Filter by minimum balance. */
+    minBalance?: number;
+    /** Filter by user-defined query name. */
+    queryName?: string;
+}
+interface HealthResponse {
+    /** Service status. */
+    status: string;
+    /** ISO timestamp of the health check. */
+    timestamp: string;
+    /** Service name. */
+    service: string;
+}
+
+declare class VocdoniCensusService extends BaseService {
+    constructor(baseURL: string);
+    /**
+     * Constructs the URI for accessing a census by its root
+     * @param censusRoot - The census root (hex-prefixed)
+     * @returns The constructed URI for the census
+     */
+    getCensusUri(censusRoot: string): string;
+    createCensus(): Promise<string>;
+    addParticipants(censusId: string, participants: CensusParticipant[]): Promise<void>;
+    getParticipants(censusId: string): Promise<CensusParticipant[]>;
+    getCensusRoot(censusId: string): Promise<string>;
+    getCensusSizeById(censusId: string): Promise<number>;
+    getCensusSizeByRoot(censusRoot: string): Promise<number>;
+    getCensusSize(censusIdOrRoot: string): Promise<number>;
+    deleteCensus(censusId: string): Promise<void>;
+    getCensusProof(censusRoot: string, key: string): Promise<CensusProof>;
+    publishCensus(censusId: string): Promise<PublishCensusResponse>;
+    getSnapshots(params?: SnapshotsQueryParams): Promise<SnapshotsResponse>;
+    getLatestSnapshot(): Promise<Snapshot>;
+    getHealth(): Promise<HealthResponse>;
+}
+
+interface BallotMode {
+    numFields: number;
+    maxValue: string;
+    minValue: string;
+    uniqueValues: boolean;
+    costFromWeight: boolean;
+    costExponent: number;
+    maxValueSum: string;
+    minValueSum: string;
+}
+interface Census {
+    censusOrigin: CensusOrigin;
+    maxVotes: string;
+    censusRoot: string;
+    censusURI: string;
+}
+interface EncryptionKey {
+    x: string;
+    y: string;
+}
+
+interface CreateProcessRequest {
+    processId: string;
+    censusRoot: string;
+    ballotMode: BallotMode;
+    signature: string;
+    /**
+     * The censusOrigin specifies the origin type of the census used in the request.
+     * This attribute allows the API to determine how the census data should be processed or verified.
+     */
+    censusOrigin: CensusOrigin;
+}
+interface CreateProcessResponse {
+    processId: string;
+    encryptionPubKey: [string, string];
+    stateRoot: string;
+    ballotMode: BallotMode;
+}
+interface GetProcessResponse {
+    id: string;
+    status: number;
+    organizationId: string;
+    encryptionKey: EncryptionKey;
+    stateRoot: string;
+    result: string[];
+    startTime: number;
+    duration: number;
+    metadataURI: string;
+    ballotMode: BallotMode;
+    census: Census;
+    metadata: {
+        title: Record<string, string>;
+        description: Record<string, string>;
+        media: {
+            header: string;
+            logo: string;
+        };
+        questions: {
+            title: Record<string, string>;
+            description: Record<string, string>;
+            choices: {
+                title: Record<string, string>;
+                value: number;
+                meta: Record<string, string>;
+            }[];
+            meta: Record<string, string>;
+        }[];
+        processType: {
+            name: string;
+            properties: Record<string, string>;
+        };
+    };
+    voteCount: string;
+    voteOverwrittenCount: string;
+    isAcceptingVotes: boolean;
+    sequencerStats: {
+        stateTransitionCount: number;
+        lastStateTransitionDate: string;
+        settledStateTransitionCount: number;
+        aggregatedVotesCount: number;
+        verifiedVotesCount: number;
+        pendingVotesCount: number;
+        currentBatchSize: number;
+        lastBatchSize: number;
+    };
+}
+interface VoteCiphertext {
+    c1: [string, string];
+    c2: [string, string];
+}
+interface VoteBallot {
+    curveType: string;
+    ciphertexts: VoteCiphertext[];
+}
+interface VoteProof {
+    pi_a: [string, string, string];
+    pi_b: [[string, string], [string, string], [string, string]];
+    pi_c: [string, string, string];
+    protocol: string;
+}
+interface VoteRequest {
+    /** The `processId` you obtained when creating the process. */
+    processId: string;
+    /** Your Merkle‐proof that you're in the census. */
+    censusProof: CensusProof;
+    /** Your encrypted ballot. */
+    ballot: VoteBallot;
+    /** The zkSNARK proof that the ballot is well‐formed. */
+    ballotProof: VoteProof;
+    /** Hash of the ballot inputs (decimal string). */
+    ballotInputsHash: string;
+    /** Your Ethereum address (hex-prefixed). */
+    address: string;
+    /** Signature over the raw bytes of the voteId. */
+    signature: string;
+    /** The vote ID (hex-prefixed). */
+    voteId: string;
+}
+interface InfoResponse {
+    circuitUrl: string;
+    circuitHash: string;
+    provingKeyUrl: string;
+    provingKeyHash: string;
+    verificationKeyUrl: string;
+    verificationKeyHash: string;
+    ballotProofWasmHelperUrl: string;
+    ballotProofWasmHelperHash: string;
+    ballotProofWasmHelperExecJsUrl: string;
+    ballotProofWasmHelperExecJsHash: string;
+    contracts: {
+        process: string;
+        organization: string;
+        stateTransitionVerifier: string;
+        resultsVerifier: string;
+    };
+    network: {
+        [key: string]: number;
+    };
+}
+declare enum VoteStatus {
+    Pending = "pending",
+    Verified = "verified",
+    Aggregated = "aggregated",
+    Processed = "processed",
+    Settled = "settled",
+    Error = "error"
+}
+interface VoteStatusResponse {
+    status: VoteStatus;
+}
+interface ListProcessesResponse {
+    processes: string[];
+}
+interface SequencerStats {
+    activeProcesses: number;
+    pendingVotes: number;
+    verifiedVotes: number;
+    aggregatedVotes: number;
+    stateTransitions: number;
+    settledStateTransitions: number;
+    lastStateTransitionDate: string;
+}
+interface WorkerStats {
+    name: string;
+    successCount: number;
+    failedCount: number;
+}
+interface WorkersResponse {
+    workers: WorkerStats[];
+}
+
+declare class VocdoniSequencerService extends BaseService {
+    constructor(baseURL: string);
+    ping(): Promise<void>;
+    createProcess(body: CreateProcessRequest): Promise<CreateProcessResponse>;
+    getProcess(processId: string): Promise<GetProcessResponse>;
+    listProcesses(): Promise<string[]>;
+    submitVote(vote: VoteRequest): Promise<void>;
+    getVoteStatus(processId: string, voteId: string): Promise<VoteStatusResponse>;
+    hasAddressVoted(processId: string, address: string): Promise<boolean>;
+    getInfo(): Promise<InfoResponse>;
+    pushMetadata(metadata: ElectionMetadata): Promise<string>;
+    getMetadata(hashOrUrl: string): Promise<ElectionMetadata>;
+    getMetadataUrl(hash: string): string;
+    getStats(): Promise<SequencerStats>;
+    getWorkers(): Promise<WorkersResponse>;
+}
+
+interface VocdoniApiServiceConfig {
+    sequencerURL: string;
+    censusURL: string;
+}
+declare class VocdoniApiService {
+    readonly census: VocdoniCensusService;
+    readonly sequencer: VocdoniSequencerService;
+    constructor(config: VocdoniApiServiceConfig);
+}
+
+/**
+ * Supported environment types
+ */
+type Environment = 'dev' | 'stg' | 'prod';
+/**
+ * URL configuration for each service
+ */
+interface ServiceUrls {
+    /** Sequencer API URL */
+    sequencer: string;
+    /** Census API URL */
+    census: string;
+}
+/**
+ * Chain configuration for each environment
+ */
+interface ChainConfig {
+    /** Chain name/ID */
+    chain: 'sepolia' | 'mainnet';
+}
+/**
+ * Environment-based URL configuration
+ */
+interface EnvironmentConfig {
+    dev: ServiceUrls & ChainConfig;
+    stg: ServiceUrls & ChainConfig;
+    prod: ServiceUrls & ChainConfig;
+}
+/**
+ * Configuration options for environment setup
+ */
+interface EnvironmentOptions {
+    /** Environment to use (defaults to 'prod') */
+    environment?: Environment;
+    /** Custom URLs to override defaults */
+    customUrls?: Partial<ServiceUrls>;
+    /** Custom chain to override default */
+    customChain?: ChainConfig['chain'];
+}
+
+/**
+ * Default URL and chain configuration for all environments
+ */
+declare const DEFAULT_ENVIRONMENT_URLS: EnvironmentConfig;
+/**
+ * Get URLs and chain configuration for a specific environment
+ */
+declare function getEnvironmentConfig(environment: Environment): ServiceUrls & ChainConfig;
+/**
+ * Get only URLs for a specific environment
+ */
+declare function getEnvironmentUrls(environment: Environment): ServiceUrls;
+/**
+ * Get chain configuration for a specific environment
+ */
+declare function getEnvironmentChain(environment: Environment): ChainConfig['chain'];
+/**
+ * Resolve URLs and chain based on environment and custom overrides
+ */
+declare function resolveConfiguration(options?: EnvironmentOptions): ServiceUrls & ChainConfig;
+/**
+ * Resolve only URLs based on environment and custom overrides
+ */
+declare function resolveUrls(options?: EnvironmentOptions): ServiceUrls;
+
+/**
+ * Interface defining the structure of deployed contract addresses across different networks.
+ * Each contract has addresses for both Sepolia testnet and Ethereum mainnet.
+ */
+interface DeployedAddresses {
+    /** Process Registry contract addresses */
+    processRegistry: {
+        /** Sepolia testnet address */
+        sepolia: string;
+        /** Ethereum mainnet address */
+        mainnet: string;
+    };
+    /** Organization Registry contract addresses */
+    organizationRegistry: {
+        /** Sepolia testnet address */
+        sepolia: string;
+        /** Ethereum mainnet address */
+        mainnet: string;
+    };
+    /** State Transition Verifier contract addresses */
+    stateTransitionVerifierGroth16: {
+        /** Sepolia testnet address */
+        sepolia: string;
+        /** Ethereum mainnet address */
+        mainnet: string;
+    };
+    /** Results Verifier contract addresses */
+    resultsVerifierGroth16: {
+        /** Sepolia testnet address */
+        sepolia: string;
+        /** Ethereum mainnet address */
+        mainnet: string;
+    };
+    /** Sequencer Registry contract addresses */
+    sequencerRegistry: {
+        /** Sepolia testnet address */
+        sepolia: string;
+        /** Ethereum mainnet address */
+        mainnet: string;
+    };
+}
+/**
+ * Deployed contract addresses imported from @vocdoni/davinci-contracts package.
+ * These addresses are used to interact with the Vocdoni voting protocol contracts
+ * on different networks.
+ */
+declare const deployedAddresses: DeployedAddresses;
+/**
+ * Enum representing the possible states of a transaction during its lifecycle.
+ * Used to track and report transaction status in the event stream.
+ */
+declare enum TxStatus {
+    /** Transaction has been submitted and is waiting to be mined */
+    Pending = "pending",
+    /** Transaction has been successfully mined and executed */
+    Completed = "completed",
+    /** Transaction was mined but reverted during execution */
+    Reverted = "reverted",
+    /** Transaction failed before or during submission */
+    Failed = "failed"
+}
+/**
+ * Union type representing the different events that can occur during a transaction's lifecycle.
+ * Each event includes relevant data based on the transaction status.
+ *
+ * @template T - The type of the successful response data
+ */
+type TxStatusEvent<T = any> = {
+    status: TxStatus.Pending;
+    hash: string;
+} | {
+    status: TxStatus.Completed;
+    response: T;
+} | {
+    status: TxStatus.Reverted;
+    reason?: string;
+} | {
+    status: TxStatus.Failed;
+    error: Error;
+};
+/**
+ * Abstract base class providing common functionality for smart contract interactions.
+ * Implements transaction handling, status monitoring, and event normalization.
+ */
+declare abstract class SmartContractService {
+    /**
+     * Sends a transaction and yields status events during its lifecycle.
+     * This method handles the complete transaction flow from submission to completion,
+     * including error handling and status updates.
+     *
+     * @template T - The type of the successful response data
+     * @param txPromise - Promise resolving to the transaction response
+     * @param responseHandler - Function to process the successful transaction result
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const txStream = await this.sendTx(
+     *   contract.someMethod(),
+     *   async () => await contract.getUpdatedValue()
+     * );
+     *
+     * for await (const event of txStream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log(`Transaction pending: ${event.hash}`);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log(`Transaction completed:`, event.response);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    protected sendTx<T>(txPromise: Promise<ContractTransactionResponse>, responseHandler: () => Promise<T>): AsyncGenerator<TxStatusEvent<T>, void, unknown>;
+    /**
+     * Executes a transaction stream and returns the result or throws an error.
+     * This is a convenience method that processes a transaction stream and either
+     * returns the successful result or throws an appropriate error.
+     *
+     * @template T - The type of the successful response data
+     * @param stream - AsyncGenerator of transaction status events
+     * @returns Promise resolving to the successful response data
+     * @throws Error if the transaction fails or reverts
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const result = await SmartContractService.executeTx(
+     *     contract.someMethod()
+     *   );
+     *   console.log('Transaction successful:', result);
+     * } catch (error) {
+     *   console.error('Transaction failed:', error);
+     * }
+     * ```
+     */
+    static executeTx<T>(stream: AsyncGenerator<TxStatusEvent<T>>): Promise<T>;
+    /**
+     * Normalizes event listener arguments between different ethers.js versions.
+     * This helper method ensures consistent event argument handling regardless of
+     * whether the event payload follows ethers v5 or v6 format.
+     *
+     * @template Args - Tuple type representing the expected event arguments
+     * @param callback - The event callback function to normalize
+     * @returns Normalized event listener function
+     *
+     * @example
+     * ```typescript
+     * contract.on('Transfer', this.normalizeListener((from: string, to: string, amount: BigInt) => {
+     *   console.log(`Transfer from ${from} to ${to}: ${amount}`);
+     * }));
+     * ```
+     */
+    protected normalizeListener<Args extends any[]>(callback: (...args: Args) => void): (...listenerArgs: any[]) => void;
+}
+
+/**
+ * @fileoverview Standardized types and interfaces for contract services
+ *
+ * This module provides consistent type definitions for callbacks, interfaces,
+ * and common data structures used across contract services.
+ */
+/**
+ * Generic callback type for contract events.
+ * @template T - Tuple type representing the event arguments
+ */
+type EntityCallback<T extends any[]> = (...args: T) => void;
+/**
+ * Callback for when an organization is created.
+ * @param id - The organization ID
+ */
+type OrganizationCreatedCallback = EntityCallback<[string]>;
+/**
+ * Callback for when an organization is updated.
+ * @param id - The organization ID
+ * @param updater - Address of the account that updated the organization
+ */
+type OrganizationUpdatedCallback = EntityCallback<[string, string]>;
+/**
+ * Callback for when an administrator is added to an organization.
+ * @param id - The organization ID
+ * @param administrator - Address of the administrator that was added
+ */
+type OrganizationAdministratorAddedCallback = EntityCallback<[string, string]>;
+/**
+ * Callback for when an administrator is removed from an organization.
+ * @param id - The organization ID
+ * @param administrator - Address of the administrator that was removed
+ * @param remover - Address of the account that removed the administrator
+ */
+type OrganizationAdministratorRemovedCallback = EntityCallback<[string, string, string]>;
+/**
+ * Callback for when a process is created.
+ * @param processID - The process ID
+ * @param creator - Address of the account that created the process
+ */
+type ProcessCreatedCallback = EntityCallback<[string, string]>;
+/**
+ * Callback for when a process status changes.
+ * @param processID - The process ID
+ * @param oldStatus - The previous status
+ * @param newStatus - The new status
+ */
+type ProcessStatusChangedCallback = EntityCallback<[string, bigint, bigint]>;
+/**
+ * Callback for when a process census is updated.
+ * @param processID - The process ID
+ * @param root - The new census root
+ * @param uri - The new census URI
+ * @param maxVotes - The maximum number of votes
+ */
+type ProcessCensusUpdatedCallback = EntityCallback<[string, string, string, bigint]>;
+/**
+ * Callback for when a process duration changes.
+ * @param processID - The process ID
+ * @param duration - The new duration
+ */
+type ProcessDurationChangedCallback = EntityCallback<[string, bigint]>;
+/**
+ * Callback for when a process state root is updated.
+ * @param processID - The process ID
+ * @param sender - Address of the account that updated the state root
+ * @param newStateRoot - The new state root
+ */
+type ProcessStateRootUpdatedCallback = EntityCallback<[string, string, bigint]>;
+/**
+ * Callback for when process results are set.
+ * @param processID - The process ID
+ * @param sender - Address of the account that set the results
+ * @param result - The results array
+ */
+type ProcessResultsSetCallback = EntityCallback<[string, string, bigint[]]>;
+
+declare enum ProcessStatus {
+    READY = 0,
+    ENDED = 1,
+    CANCELED = 2,
+    PAUSED = 3,
+    RESULTS = 4
+}
+declare class ProcessRegistryService extends SmartContractService {
+    private contract;
+    constructor(contractAddress: string, runner: ContractRunner);
+    getProcess(processID: string): Promise<_vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.ProcessStructOutput>;
+    getProcessCount(): Promise<number>;
+    getChainID(): Promise<string>;
+    getNextProcessId(organizationId: string): Promise<string>;
+    getProcessEndTime(processID: string): Promise<bigint>;
+    getRVerifierVKeyHash(): Promise<string>;
+    getSTVerifierVKeyHash(): Promise<string>;
+    getMaxCensusOrigin(): Promise<bigint>;
+    getMaxStatus(): Promise<bigint>;
+    getProcessNonce(address: string): Promise<bigint>;
+    getProcessDirect(processID: string): Promise<[bigint, string, _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.EncryptionKeyStructOutput, bigint, bigint, bigint, bigint, bigint, bigint, bigint, string, _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.BallotModeStructOutput, _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.CensusStructOutput] & {
+        status: bigint;
+        organizationId: string;
+        encryptionKey: _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.EncryptionKeyStructOutput;
+        latestStateRoot: bigint;
+        startTime: bigint;
+        duration: bigint;
+        voteCount: bigint;
+        voteOverwriteCount: bigint;
+        creationBlock: bigint;
+        batchNumber: bigint;
+        metadataURI: string;
+        ballotMode: _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.BallotModeStructOutput;
+        census: _vocdoni_davinci_contracts_dist_src_ProcessRegistry.IProcessRegistry.CensusStructOutput;
+    }>;
+    getRVerifier(): Promise<string>;
+    getSTVerifier(): Promise<string>;
+    newProcess(status: ProcessStatus, startTime: number, duration: number, ballotMode: BallotMode, census: Census, metadata: string, encryptionKey: EncryptionKey, initStateRoot: bigint): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    setProcessStatus(processID: string, newStatus: ProcessStatus): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    setProcessCensus(processID: string, census: Census): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    setProcessDuration(processID: string, duration: number): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    /**
+     * Matches the on-chain `submitStateTransition(processId, proof, input)`
+     */
+    submitStateTransition(processID: string, proof: string, input: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    /**
+     * Sets the results for a voting process.
+     *
+     * @param processID - The ID of the process to set results for
+     * @param proof - Zero-knowledge proof validating the results
+     * @param input - Input data for the proof verification
+     * @returns A transaction stream that resolves to success status
+     */
+    setProcessResults(processID: string, proof: string, input: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    onProcessCreated(cb: ProcessCreatedCallback): void;
+    onProcessStatusChanged(cb: ProcessStatusChangedCallback): void;
+    onCensusUpdated(cb: ProcessCensusUpdatedCallback): void;
+    onProcessDurationChanged(cb: ProcessDurationChangedCallback): void;
+    onStateRootUpdated(cb: ProcessStateRootUpdatedCallback): void;
+    onProcessResultsSet(cb: ProcessResultsSetCallback): void;
+    removeAllListeners(): void;
+}
+
+interface OrganizationInfo {
+    name: string;
+    metadataURI: string;
+}
+declare class OrganizationRegistryService extends SmartContractService {
+    private contract;
+    constructor(contractAddress: string, runner: ContractRunner);
+    getOrganization(id: string): Promise<OrganizationInfo>;
+    existsOrganization(id: string): Promise<boolean>;
+    isAdministrator(id: string, address: string): Promise<boolean>;
+    getOrganizationCount(): Promise<number>;
+    createOrganization(name: string, metadataURI: string, administrators: string[]): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    updateOrganization(id: string, name: string, metadataURI: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    addAdministrator(id: string, administrator: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    removeAdministrator(id: string, administrator: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    deleteOrganization(id: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, void, unknown>;
+    onOrganizationCreated(cb: OrganizationCreatedCallback): void;
+    onOrganizationUpdated(cb: OrganizationUpdatedCallback): void;
+    onAdministratorAdded(cb: OrganizationAdministratorAddedCallback): void;
+    onAdministratorRemoved(cb: OrganizationAdministratorRemovedCallback): void;
+    removeAllListeners(): void;
+}
+
+interface ProofInputs {
+    fields: string[];
+    num_fields: string;
+    unique_values: string;
+    max_value: string;
+    min_value: string;
+    max_value_sum: string;
+    min_value_sum: string;
+    cost_exponent: string;
+    cost_from_weight: string;
+    address: string;
+    weight: string;
+    process_id: string;
+    vote_id: string;
+    encryption_pubkey: [string, string];
+    k: string;
+    cipherfields: string[];
+    inputs_hash: string;
+}
+interface Groth16Proof {
+    pi_a: [string, string, string];
+    pi_b: [[string, string], [string, string], [string, string]];
+    pi_c: [string, string, string];
+    protocol: string;
+    curve: string;
+}
+interface CircomProofOptions {
+    wasmUrl?: string;
+    zkeyUrl?: string;
+    vkeyUrl?: string;
+    /** Optional SHA-256 hash to verify circuit WASM file integrity */
+    wasmHash?: string;
+    /** Optional SHA-256 hash to verify proving key file integrity */
+    zkeyHash?: string;
+    /** Optional SHA-256 hash to verify verification key file integrity */
+    vkeyHash?: string;
+}
+declare class CircomProof {
+    private readonly wasmUrl?;
+    private readonly zkeyUrl?;
+    private readonly vkeyUrl?;
+    private readonly wasmHash?;
+    private readonly zkeyHash?;
+    private readonly vkeyHash?;
+    private wasmCache;
+    private zkeyCache;
+    private vkeyCache;
+    constructor(opts?: CircomProofOptions);
+    /**
+     * Computes SHA-256 hash of the given data and compares it with the expected hash.
+     * @param data - The data to hash (string or ArrayBuffer or Uint8Array)
+     * @param expectedHash - The expected SHA-256 hash in hexadecimal format
+     * @param filename - The filename for error reporting
+     * @throws Error if the computed hash doesn't match the expected hash
+     */
+    private verifyHash;
+    /**
+     * Generate a zk‐SNARK proof.
+     * If you didn't pass wasmUrl/zkeyUrl in the constructor you must supply them here.
+     */
+    generate(inputs: ProofInputs, urls?: {
+        wasmUrl?: string;
+        zkeyUrl?: string;
+    }): Promise<{
+        proof: Groth16Proof;
+        publicSignals: string[];
+    }>;
+    verify(proof: Groth16Proof, publicSignals: string[], urlOverride?: string): Promise<boolean>;
+}
+
+interface DavinciCryptoInputs {
+    address: string;
+    processID: string;
+    encryptionKey: [string, string];
+    k?: string;
+    weight: string;
+    fieldValues: string[];
+    ballotMode: BallotMode;
+}
+interface DavinciCryptoCiphertext {
+    c1: [string, string];
+    c2: [string, string];
+}
+interface DavinciCryptoOutput {
+    processId: string;
+    address: string;
+    ballot: {
+        curveType: string;
+        ciphertexts: DavinciCryptoCiphertext[];
+    };
+    ballotInputsHash: string;
+    voteId: string;
+    circomInputs: ProofInputs;
+}
+interface CSPSignOutput {
+    censusOrigin: CensusOrigin;
+    root: string;
+    address: string;
+    processId: string;
+    publicKey: string;
+    signature: string;
+}
+interface RawResult<T = any> {
+    error?: string;
+    data?: T;
+}
+interface GoDavinciCryptoWasm {
+    proofInputs(inputJson: string): RawResult<DavinciCryptoOutput>;
+    cspSign(censusOrigin: number, privKey: string, processId: string, address: string): RawResult<CSPSignOutput>;
+    cspVerify(cspProof: string): RawResult<boolean>;
+    cspCensusRoot(censusOrigin: number, privKey: string): RawResult<{
+        root: string;
+    }>;
+}
+declare global {
+    var Go: new () => {
+        importObject: Record<string, any>;
+        run(instance: WebAssembly.Instance): Promise<void>;
+    };
+    var DavinciCrypto: GoDavinciCryptoWasm;
+}
+interface DavinciCryptoOptions {
+    /** URL to wasm_exec.js */
+    wasmExecUrl: string;
+    /** URL to the compiled davinci_crypto.wasm */
+    wasmUrl: string;
+    /** How long (ms) to wait for the Go runtime to attach DavinciCrypto */
+    initTimeoutMs?: number;
+    /** Optional SHA-256 hash to verify wasm_exec.js integrity */
+    wasmExecHash?: string;
+    /** Optional SHA-256 hash to verify davinci_crypto.wasm integrity */
+    wasmHash?: string;
+}
+declare class DavinciCrypto {
+    private go;
+    private initialized;
+    private readonly wasmExecUrl;
+    private readonly wasmUrl;
+    private readonly initTimeoutMs;
+    private readonly wasmExecHash?;
+    private readonly wasmHash?;
+    private static wasmExecCache;
+    private static wasmBinaryCache;
+    constructor(opts: DavinciCryptoOptions);
+    /**
+     * Computes SHA-256 hash of the given data and compares it with the expected hash.
+     * @param data - The data to hash (string or ArrayBuffer)
+     * @param expectedHash - The expected SHA-256 hash in hexadecimal format
+     * @param filename - The filename for error reporting
+     * @throws Error if the computed hash doesn't match the expected hash
+     */
+    private verifyHash;
+    /**
+     * Must be awaited before calling `proofInputs()`.
+     * Safe to call multiple times.
+     */
+    init(): Promise<void>;
+    /**
+     * Convert your inputs into JSON, hand off to Go/WASM, then parse & return.
+     * @throws if called before `await init()`, or if Go returns an error
+     */
+    proofInputs(inputs: DavinciCryptoInputs): Promise<DavinciCryptoOutput>;
+    /**
+     * Generate a CSP (Credential Service Provider) signature for census proof.
+     * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+     * @param privKey - The private key in hex format
+     * @param processId - The process ID in hex format
+     * @param address - The address in hex format
+     * @returns The CSP proof as a parsed JSON object
+     * @throws if called before `await init()`, or if Go returns an error
+     */
+    cspSign(censusOrigin: CensusOrigin, privKey: string, processId: string, address: string): Promise<CSPSignOutput>;
+    /**
+     * Verify a CSP (Credential Service Provider) proof.
+     * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+     * @param root - The census root
+     * @param address - The address
+     * @param processId - The process ID
+     * @param publicKey - The public key
+     * @param signature - The signature
+     * @returns The verification result
+     * @throws if called before `await init()`, or if Go returns an error
+     */
+    cspVerify(censusOrigin: CensusOrigin, root: string, address: string, processId: string, publicKey: string, signature: string): Promise<boolean>;
+    /**
+     * Generate a CSP (Credential Service Provider) census root.
+     * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+     * @param privKey - The private key in hex format
+     * @returns The census root as a hexadecimal string
+     * @throws if called before `await init()`, or if Go returns an error
+     */
+    cspCensusRoot(censusOrigin: CensusOrigin, privKey: string): Promise<string>;
+}
+
+/**
+ * Base interface with shared fields between ProcessConfig and ProcessInfo
+ */
+interface BaseProcess {
+    /** Process title */
+    title: string;
+    /** Process description (optional) */
+    description?: string;
+    /** Census configuration */
+    census: {
+        /** Census type - MerkleTree or CSP */
+        type: CensusOrigin;
+        /** Census root */
+        root: string;
+        /** Census size */
+        size: number;
+        /** Census URI */
+        uri: string;
+    };
+    /** Ballot configuration */
+    ballot: BallotMode;
+    /** Election questions and choices (required) */
+    questions: Array<{
+        title: string;
+        description?: string;
+        choices: Array<{
+            title: string;
+            value: number;
+        }>;
+    }>;
+}
+/**
+ * Configuration for creating a process
+ */
+interface ProcessConfig extends BaseProcess {
+    /** Process timing - use either duration-based or date-based configuration */
+    timing: {
+        /** Start date/time (Date object, ISO string, or Unix timestamp, default: now + 60 seconds) */
+        startDate?: Date | string | number;
+        /** Duration in seconds (required if endDate is not provided) */
+        duration?: number;
+        /** End date/time (Date object, ISO string, or Unix timestamp, cannot be used with duration) */
+        endDate?: Date | string | number;
+    };
+}
+/**
+ * Result of process creation
+ */
+interface ProcessCreationResult {
+    /** The created process ID */
+    processId: string;
+    /** Transaction hash of the on-chain process creation */
+    transactionHash: string;
+}
+/**
+ * User-friendly process information that extends the base process with additional runtime data
+ */
+interface ProcessInfo extends BaseProcess {
+    /** The process ID */
+    processId: string;
+    /** Current process status */
+    status: ProcessStatus;
+    /** Process creator address */
+    creator: string;
+    /** Start date as Date object */
+    startDate: Date;
+    /** End date as Date object */
+    endDate: Date;
+    /** Duration in seconds */
+    duration: number;
+    /** Time remaining in seconds (0 if ended, negative if not started) */
+    timeRemaining: number;
+    /** Process results (array of BigInt values) */
+    result: bigint[];
+    /** Number of votes cast */
+    voteCount: number;
+    /** Number of vote overwrites */
+    voteOverwriteCount: number;
+    /** Metadata URI */
+    metadataURI: string;
+    /** Raw contract data (for advanced users) */
+    raw?: any;
+}
+/**
+ * Service that orchestrates the complete process creation workflow
+ */
+declare class ProcessOrchestrationService {
+    private processRegistry;
+    private apiService;
+    private organizationRegistry;
+    private getCrypto;
+    private signer;
+    constructor(processRegistry: ProcessRegistryService, apiService: VocdoniApiService, organizationRegistry: OrganizationRegistryService, getCrypto: () => Promise<DavinciCrypto>, signer: Signer);
+    /**
+     * Gets user-friendly process information by transforming raw contract data
+     * @param processId - The process ID to fetch
+     * @returns Promise resolving to the user-friendly process information
+     */
+    getProcess(processId: string): Promise<ProcessInfo>;
+    /**
+     * Creates a complete voting process with minimal configuration
+     * This method handles all the complex orchestration internally
+     */
+    createProcess(config: ProcessConfig): Promise<ProcessCreationResult>;
+    /**
+     * Validates and calculates timing parameters
+     */
+    private calculateTiming;
+    /**
+     * Converts various date formats to Unix timestamp
+     */
+    private dateToUnixTimestamp;
+    /**
+     * Creates metadata from the simplified configuration
+     */
+    private createMetadata;
+}
+
+/**
+ * Simplified vote configuration interface for end users
+ */
+interface VoteConfig {
+    /** The process ID to vote in */
+    processId: string;
+    /** The voter's choices - array of selected values for each question */
+    choices: number[];
+    /** Optional: Custom randomness for vote encryption (will be generated if not provided) */
+    randomness?: string;
+}
+/**
+ * Result of vote submission
+ */
+interface VoteResult {
+    /** The unique vote ID */
+    voteId: string;
+    /** The transaction signature */
+    signature: string;
+    /** The voter's address */
+    voterAddress: string;
+    /** The process ID */
+    processId: string;
+    /** Current vote status */
+    status: VoteStatus;
+}
+/**
+ * Vote status information
+ */
+interface VoteStatusInfo {
+    /** The vote ID */
+    voteId: string;
+    /** Current status of the vote */
+    status: VoteStatus;
+    /** The process ID */
+    processId: string;
+}
+/**
+ * Service that orchestrates the complete voting workflow
+ * Handles all the complex cryptographic operations and API calls internally
+ */
+declare class VoteOrchestrationService {
+    private apiService;
+    private getCrypto;
+    private signer;
+    private censusProviders;
+    constructor(apiService: VocdoniApiService, getCrypto: () => Promise<DavinciCrypto>, signer: Signer, censusProviders?: CensusProviders);
+    /**
+     * Submit a vote with simplified configuration
+     * This method handles all the complex orchestration internally:
+     * - Fetches process information and encryption keys
+     * - Gets census proof (Merkle or CSP)
+     * - Generates cryptographic proofs
+     * - Signs and submits the vote
+     *
+     * @param config - Simplified vote configuration
+     * @returns Promise resolving to vote submission result
+     */
+    submitVote(config: VoteConfig): Promise<VoteResult>;
+    /**
+     * Get the status of a submitted vote
+     *
+     * @param processId - The process ID
+     * @param voteId - The vote ID
+     * @returns Promise resolving to vote status information
+     */
+    getVoteStatus(processId: string, voteId: string): Promise<VoteStatusInfo>;
+    /**
+     * Check if an address has voted in a process
+     *
+     * @param processId - The process ID
+     * @param address - The voter's address
+     * @returns Promise resolving to boolean indicating if the address has voted
+     */
+    hasAddressVoted(processId: string, address: string): Promise<boolean>;
+    /**
+     * Wait for a vote to reach a specific status
+     *
+     * @param processId - The process ID
+     * @param voteId - The vote ID
+     * @param targetStatus - The target status to wait for (default: "settled")
+     * @param timeoutMs - Maximum time to wait in milliseconds (default: 300000 = 5 minutes)
+     * @param pollIntervalMs - Polling interval in milliseconds (default: 5000 = 5 seconds)
+     * @returns Promise resolving to final vote status
+     */
+    waitForVoteStatus(processId: string, voteId: string, targetStatus?: VoteStatus, timeoutMs?: number, pollIntervalMs?: number): Promise<VoteStatusInfo>;
+    /**
+     * Get census proof based on census origin type
+     */
+    private getCensusProof;
+    /**
+     * Generate vote proof inputs using DavinciCrypto
+     */
+    private generateVoteProofInputs;
+    /**
+     * Validate user choices based on ballot mode
+     */
+    private validateChoices;
+    /**
+     * Generate zk-SNARK proof using CircomProof
+     */
+    private generateZkProof;
+    private hexToBytes;
+    /**
+     * Sign the vote using the signer
+     */
+    private signVote;
+    /**
+     * Submit the vote request to the sequencer
+     */
+    private submitVoteRequest;
+}
+
+/**
+ * @fileoverview Standardized error classes for contract services
+ *
+ * This module provides a consistent error hierarchy for all contract service operations.
+ * All errors extend from ContractServiceError and include operation context for better debugging.
+ */
+/**
+ * Abstract base class for all contract service errors.
+ * Provides consistent error structure with operation context.
+ */
+declare abstract class ContractServiceError extends Error {
+    readonly operation: string;
+    /**
+     * Creates a new ContractServiceError instance.
+     *
+     * @param message - The error message describing what went wrong
+     * @param operation - The operation that was being performed when the error occurred
+     */
+    constructor(message: string, operation: string);
+}
+/**
+ * Error thrown when organization creation fails.
+ */
+declare class OrganizationCreateError extends ContractServiceError {
+}
+/**
+ * Error thrown when organization update fails.
+ */
+declare class OrganizationUpdateError extends ContractServiceError {
+}
+/**
+ * Error thrown when organization deletion fails.
+ */
+declare class OrganizationDeleteError extends ContractServiceError {
+}
+/**
+ * Error thrown when administrator operations fail.
+ */
+declare class OrganizationAdministratorError extends ContractServiceError {
+}
+/**
+ * Error thrown when process creation fails.
+ */
+declare class ProcessCreateError extends ContractServiceError {
+}
+/**
+ * Error thrown when process status change fails.
+ */
+declare class ProcessStatusError extends ContractServiceError {
+}
+/**
+ * Error thrown when process census update fails.
+ */
+declare class ProcessCensusError extends ContractServiceError {
+}
+/**
+ * Error thrown when process duration change fails.
+ */
+declare class ProcessDurationError extends ContractServiceError {
+}
+/**
+ * Error thrown when state transition submission fails.
+ */
+declare class ProcessStateTransitionError extends ContractServiceError {
+}
+/**
+ * Error thrown when process result setting fails.
+ */
+declare class ProcessResultError extends ContractServiceError {
+}
+
+/**
+ * Creates the signature message for process creation.
+ * @param processId - The process ID (with or without 0x prefix)
+ * @returns The message string to be signed
+ */
+declare function createProcessSignatureMessage(processId: string): string;
+/**
+ * Signs the process creation message with the provided signer.
+ * @param processId - The process ID (with or without 0x prefix)
+ * @param signer - The signer (Wallet or Signer) to sign with
+ * @returns Promise resolving to the signature string
+ */
+declare function signProcessCreation(processId: string, signer: Signer | Wallet): Promise<string>;
+/**
+ * Validates that a process ID is a valid 64-character hex string (32 bytes).
+ * @param processId - The process ID to validate
+ * @returns True if valid, false otherwise
+ */
+declare function validateProcessId(processId: string): boolean;
+
+export { BaseService, CircomProof, ContractServiceError, DEFAULT_ENVIRONMENT_URLS, DavinciCrypto, ElectionMetadataTemplate, ElectionResultsTypeNames, OrganizationAdministratorError, OrganizationCreateError, OrganizationDeleteError, OrganizationRegistryService, OrganizationUpdateError, ProcessCensusError, ProcessCreateError, ProcessDurationError, ProcessOrchestrationService, ProcessRegistryService, ProcessResultError, ProcessStateTransitionError, ProcessStatus, ProcessStatusError, SmartContractService, TxStatus, VocdoniApiService, VocdoniSequencerService, VoteOrchestrationService, VoteStatus, createProcessSignatureMessage, deployedAddresses, getElectionMetadataTemplate, getEnvironmentChain, getEnvironmentConfig, getEnvironmentUrls, resolveConfiguration, resolveUrls, signProcessCreation, validateProcessId };
+export type { AbstainProperties, AnyJson, ApiError, ApprovalProperties, BallotMode, BaseProcess, BudgetProperties, CSPSignOutput, Census, ChainConfig, Choice, ChoiceProperties, CircomProofOptions, CreateProcessRequest, CreateProcessResponse, CustomMeta, DavinciCryptoCiphertext, DavinciCryptoInputs, DavinciCryptoOptions, DavinciCryptoOutput, DeployedAddresses, ElectionMetadata, ElectionResultsType, EncryptionKey, EntityCallback, Environment, EnvironmentConfig, EnvironmentOptions, GetProcessResponse, Groth16Proof, IChoice, IQuestion, InfoResponse, JsonArray, JsonMap, ListProcessesResponse, MultiLanguage, OrganizationAdministratorAddedCallback, OrganizationAdministratorRemovedCallback, OrganizationCreatedCallback, OrganizationInfo, OrganizationUpdatedCallback, ProcessCensusUpdatedCallback, ProcessConfig, ProcessCreatedCallback, ProcessCreationResult, ProcessDurationChangedCallback, ProcessInfo, ProcessResultsSetCallback, ProcessStateRootUpdatedCallback, ProcessStatusChangedCallback, ProofInputs, ProtocolVersion, QuadraticProperties, Question, SequencerStats, ServiceUrls, TxStatusEvent, VocdoniApiServiceConfig, VoteBallot, VoteCiphertext, VoteConfig, VoteProof, VoteRequest, VoteResult, VoteStatusInfo, VoteStatusResponse, WorkerStats, WorkersResponse };