@vocdoni/davinci-sdk 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { ContractTransactionResponse, ContractRunner, Signer, Wallet } from 'ethers';
+import { ContractTransactionResponse, BaseContract, ContractEventName, EventFilter, 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;
@@ -113,7 +113,7 @@ declare enum CensusOrigin {
     /** Indicates that the census is provided by a Credential Service Provider (CSP) */
     CensusOriginCSP = 2
 }
-interface CensusParticipant {
+interface CensusParticipant$1 {
     key: string;
     weight?: string;
 }
@@ -167,6 +167,22 @@ interface CensusProviders {
     /** Required provider for CSP census proof generation */
     csp?: CSPCensusProofProvider;
 }
+/**
+ * Type guard to check if an object is a valid MerkleCensusProof
+ */
+declare function isMerkleCensusProof(proof: any): proof is MerkleCensusProof;
+/**
+ * Type guard to check if an object is a valid CSPCensusProof
+ */
+declare function isCSPCensusProof(proof: any): proof is CSPCensusProof;
+/**
+ * Assertion function to validate MerkleCensusProof
+ */
+declare function assertMerkleCensusProof(proof: unknown): asserts proof is MerkleCensusProof;
+/**
+ * Assertion function to validate CSPCensusProof
+ */
+declare function assertCSPCensusProof(proof: unknown): asserts proof is CSPCensusProof;
 interface PublishCensusResponse {
     /** The Merkle root of the published census (hex-prefixed). */
     root: string;
@@ -231,6 +247,10 @@ interface SnapshotsQueryParams {
     /** Filter by user-defined query name. */
     queryName?: string;
 }
+interface CensusSizeResponse {
+    /** The number of participants in the census. */
+    size: number;
+}
 interface HealthResponse {
     /** Service status. */
     status: string;
@@ -249,8 +269,8 @@ declare class VocdoniCensusService extends BaseService {
      */
     getCensusUri(censusRoot: string): string;
     createCensus(): Promise<string>;
-    addParticipants(censusId: string, participants: CensusParticipant[]): Promise<void>;
-    getParticipants(censusId: string): Promise<CensusParticipant[]>;
+    addParticipants(censusId: string, participants: CensusParticipant$1[]): Promise<void>;
+    getParticipants(censusId: string): Promise<CensusParticipant$1[]>;
     getCensusRoot(censusId: string): Promise<string>;
     getCensusSizeById(censusId: string): Promise<number>;
     getCensusSizeByRoot(censusRoot: string): Promise<number>;
@@ -263,6 +283,168 @@ declare class VocdoniCensusService extends BaseService {
     getHealth(): Promise<HealthResponse>;
 }
 
+/**
+ * Census type enumeration
+ */
+declare enum CensusType {
+    PLAIN = "plain",
+    WEIGHTED = "weighted",
+    CSP = "csp"
+}
+/**
+ * Re-export CensusParticipant from types for convenience
+ * Extended to make weight required (base type has optional weight)
+ */
+interface CensusParticipant extends CensusParticipant$1 {
+    weight: string;
+}
+/**
+ * Abstract base class for all census types
+ */
+declare abstract class Census {
+    protected _censusId: string | null;
+    protected _censusRoot: string | null;
+    protected _censusURI: string | null;
+    protected _type: CensusType;
+    protected _size: number | null;
+    constructor(type: CensusType);
+    get censusId(): string | null;
+    get censusRoot(): string | null;
+    get censusURI(): string | null;
+    get type(): CensusType;
+    get size(): number | null;
+    get isPublished(): boolean;
+    /**
+     * Convert CensusType to CensusOrigin enum for API compatibility
+     */
+    get censusOrigin(): CensusOrigin;
+}
+
+/**
+ * Plain census where all participants have equal voting power (weight=1)
+ * Simpler API - just add addresses without specifying weights
+ */
+declare class PlainCensus extends Census {
+    private _participants;
+    constructor();
+    /**
+     * Add participant(s) with automatic weight=1
+     * @param addresses - Single address or array of addresses
+     */
+    add(addresses: string | string[]): void;
+    /**
+     * Remove participant by address
+     */
+    remove(address: string): void;
+    /**
+     * Get all participants as CensusParticipant array (for API)
+     * All participants have weight="1"
+     */
+    get participants(): CensusParticipant[];
+    /**
+     * Get addresses only
+     */
+    get addresses(): string[];
+    private validateAddress;
+    /**
+     * Internal method called after publishing
+     * @internal
+     */
+    _setPublishedData(root: string, uri: string, size: number, censusId?: string): void;
+}
+
+/**
+ * Participant with flexible weight type for WeightedCensus
+ * Weight can be string, number, or bigint - will be normalized to string internally
+ */
+interface WeightedParticipant {
+    key: string;
+    weight: string | number | bigint;
+}
+/**
+ * Weighted census where participants can have different voting power
+ * Requires specifying weight for each participant
+ */
+declare class WeightedCensus extends Census {
+    private _participants;
+    constructor();
+    /**
+     * Add participant(s) with custom weights
+     * Weight can be provided as string, number, or bigint - will be converted to string internally
+     * @param participant - Single participant or array of participants with custom weights
+     */
+    add(participant: WeightedParticipant | WeightedParticipant[]): void;
+    /**
+     * Remove participant by address
+     */
+    remove(address: string): void;
+    /**
+     * Get all participants as CensusParticipant array
+     */
+    get participants(): CensusParticipant[];
+    /**
+     * Get participant addresses
+     */
+    get addresses(): string[];
+    /**
+     * Get weight for specific address
+     */
+    getWeight(address: string): string | undefined;
+    /**
+     * Normalizes weight from string, number, or bigint to string
+     */
+    private normalizeWeight;
+    private validateParticipant;
+    /**
+     * Internal method called after publishing
+     * @internal
+     */
+    _setPublishedData(root: string, uri: string, size: number, censusId?: string): void;
+}
+
+/**
+ * CSP (Certificate Service Provider) census
+ * Uses a public key and CSP server URI instead of a participant list
+ */
+declare class CspCensus extends Census {
+    private _publicKey;
+    private _cspURI;
+    constructor(publicKey: string, cspURI: string, size: number);
+    get publicKey(): string;
+    get cspURI(): string;
+}
+
+/**
+ * Published census - represents a census that has already been published
+ * Use this when you have the census root, URI, and size from a previous publication
+ */
+declare class PublishedCensus extends Census {
+    constructor(type: CensusType, root: string, uri: string, size: number);
+}
+
+/**
+ * Orchestrates census creation and publishing
+ */
+declare class CensusOrchestrator {
+    private censusService;
+    constructor(censusService: VocdoniCensusService);
+    /**
+     * Publishes a PlainCensus or WeightedCensus
+     * Creates a working census, adds participants, and publishes it
+     */
+    publish(census: PlainCensus | WeightedCensus): Promise<void>;
+    /**
+     * Gets census data for process creation
+     * Throws if census is not published
+     */
+    getCensusData(census: Census): {
+        type: CensusOrigin;
+        root: string;
+        uri: string;
+        size: number;
+    };
+}
+
 interface BallotMode {
     numFields: number;
     maxValue: string;
@@ -273,7 +455,7 @@ interface BallotMode {
     maxValueSum: string;
     minValueSum: string;
 }
-interface Census {
+interface CensusData {
     censusOrigin: CensusOrigin;
     maxVotes: string;
     censusRoot: string;
@@ -312,7 +494,7 @@ interface GetProcessResponse {
     duration: number;
     metadataURI: string;
     ballotMode: BallotMode;
-    census: Census;
+    census: CensusData;
     metadata: {
         title: Record<string, string>;
         description: Record<string, string>;
@@ -461,118 +643,6 @@ declare class VocdoniApiService {
     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.
@@ -608,9 +678,14 @@ type TxStatusEvent<T = any> = {
 };
 /**
  * Abstract base class providing common functionality for smart contract interactions.
- * Implements transaction handling, status monitoring, and event normalization.
+ * Implements transaction handling, status monitoring, event normalization, and
+ * event listener management with automatic fallback for RPCs that don't support eth_newFilter.
  */
 declare abstract class SmartContractService {
+    /** Active polling intervals for event listeners using fallback mode */
+    private pollingIntervals;
+    /** Default polling interval in milliseconds for event listener fallback */
+    protected eventPollingInterval: number;
     /**
      * Sends a transaction and yields status events during its lifecycle.
      * This method handles the complete transaction flow from submission to completion,
@@ -681,6 +756,59 @@ declare abstract class SmartContractService {
      * ```
      */
     protected normalizeListener<Args extends any[]>(callback: (...args: Args) => void): (...listenerArgs: any[]) => void;
+    /**
+     * Sets up an event listener with automatic fallback for RPCs that don't support eth_newFilter.
+     * First attempts to use contract.on() which relies on eth_newFilter. If the RPC doesn't support
+     * this method (error code -32601), automatically falls back to polling with queryFilter.
+     *
+     * @template Args - Tuple type representing the event arguments
+     * @param contract - The contract instance to listen to
+     * @param eventFilter - The event filter to listen for
+     * @param callback - The callback function to invoke when the event occurs
+     *
+     * @example
+     * ```typescript
+     * this.setupEventListener(
+     *   this.contract,
+     *   this.contract.filters.Transfer(),
+     *   (from: string, to: string, amount: bigint) => {
+     *     console.log(`Transfer: ${from} -> ${to}: ${amount}`);
+     *   }
+     * );
+     * ```
+     */
+    protected setupEventListener<Args extends any[]>(contract: BaseContract, eventFilter: ContractEventName | EventFilter, callback: (...args: Args) => void): Promise<void>;
+    /**
+     * Checks if an error indicates that the RPC method is unsupported or filter operations are not working.
+     * This includes:
+     * - Method not found (-32601): RPC doesn't support eth_newFilter
+     * - Filter not found (-32000): RPC doesn't properly maintain filters
+     *
+     * @param error - The error to check
+     * @returns true if the error indicates unsupported or broken filter functionality
+     */
+    private isUnsupportedMethodError;
+    /**
+     * Sets up a polling-based event listener as fallback when eth_newFilter is not supported.
+     * Periodically queries for new events and invokes the callback for each new event found.
+     *
+     * @template Args - Tuple type representing the event arguments
+     * @param contract - The contract instance to poll
+     * @param eventFilter - The event filter to poll for
+     * @param callback - The callback function to invoke for each event
+     */
+    private setupPollingListener;
+    /**
+     * Clears all active polling intervals.
+     * Should be called when removing all listeners or cleaning up the service.
+     */
+    protected clearPollingIntervals(): void;
+    /**
+     * Sets the polling interval for event listeners using the fallback mechanism.
+     *
+     * @param intervalMs - Polling interval in milliseconds
+     */
+    setEventPollingInterval(intervalMs: number): void;
 }
 
 /**
@@ -797,13 +925,13 @@ declare class ProcessRegistryService extends SmartContractService {
     }>;
     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<{
+    newProcess(status: ProcessStatus, startTime: number, duration: number, ballotMode: BallotMode, census: CensusData, 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<{
+    setProcessCensus(processID: string, census: CensusData): AsyncGenerator<TxStatusEvent<{
         success: boolean;
     }>, void, unknown>;
     setProcessDuration(processID: string, duration: number): AsyncGenerator<TxStatusEvent<{
@@ -1096,7 +1224,22 @@ interface BaseProcess {
 /**
  * Configuration for creating a process
  */
-interface ProcessConfig extends BaseProcess {
+interface ProcessConfig extends Omit<BaseProcess, 'census'> {
+    /**
+     * Census - either a Census object (PlainCensus, WeightedCensus, CspCensus, PublishedCensus)
+     * or manual configuration. If a Census object is provided and not published, it will be
+     * automatically published.
+     */
+    census: Census | {
+        /** Census type - MerkleTree or CSP */
+        type: CensusOrigin;
+        /** Census root */
+        root: string;
+        /** Census size */
+        size: number;
+        /** Census URI */
+        uri: string;
+    };
     /** 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) */
@@ -1154,7 +1297,13 @@ declare class ProcessOrchestrationService {
     private organizationRegistry;
     private getCrypto;
     private signer;
+    private censusOrchestrator;
     constructor(processRegistry: ProcessRegistryService, apiService: VocdoniApiService, organizationRegistry: OrganizationRegistryService, getCrypto: () => Promise<DavinciCrypto>, signer: Signer);
+    /**
+     * Handles census - auto-publishes if needed and returns census config
+     * @private
+     */
+    private handleCensus;
     /**
      * Gets user-friendly process information by transforming raw contract data
      * @param processId - The process ID to fetch
@@ -1162,10 +1311,65 @@ declare class ProcessOrchestrationService {
      */
     getProcess(processId: string): Promise<ProcessInfo>;
     /**
-     * Creates a complete voting process with minimal configuration
-     * This method handles all the complex orchestration internally
+     * Creates a complete voting process and returns an async generator that yields transaction status events.
+     * This method allows you to monitor the transaction progress in real-time.
+     *
+     * @param config - Process configuration
+     * @returns AsyncGenerator yielding transaction status events with ProcessCreationResult
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.createProcessStream({
+     *   title: "My Election",
+     *   description: "A simple election",
+     *   census: { ... },
+     *   ballot: { ... },
+     *   timing: { ... },
+     *   questions: [ ... ]
+     * });
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("Process created:", event.response.processId);
+     *       console.log("Transaction hash:", event.response.transactionHash);
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    createProcessStream(config: ProcessConfig): AsyncGenerator<TxStatusEvent<ProcessCreationResult>>;
+    /**
+     * Creates a complete voting process with minimal configuration.
+     * This is the ultra-easy method for end users that handles all the complex orchestration internally.
+     *
+     * For real-time transaction status updates, use createProcessStream() instead.
+     *
+     * The method automatically:
+     * - Gets encryption keys and initial state root from the sequencer
+     * - Handles process creation signatures
+     * - Coordinates between sequencer API and on-chain contract calls
+     * - Creates and pushes metadata
+     * - Submits the on-chain transaction
+     *
+     * @param config - Simplified process configuration
+     * @returns Promise resolving to the process creation result
      */
     createProcess(config: ProcessConfig): Promise<ProcessCreationResult>;
+    /**
+     * Prepares all data needed for process creation
+     * @private
+     */
+    private prepareProcessCreation;
     /**
      * Validates and calculates timing parameters
      */
@@ -1178,85 +1382,326 @@ declare class ProcessOrchestrationService {
      * 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
+     * Ends a voting process by setting its status to ENDED.
+     * Returns an async generator that yields transaction status events.
      *
-     * @param config - Simplified vote configuration
-     * @returns Promise resolving to vote submission result
+     * @param processId - The process ID to end
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.endProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("Process ended successfully");
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
      */
-    submitVote(config: VoteConfig): Promise<VoteResult>;
+    endProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>>;
     /**
-     * Get the status of a submitted vote
+     * Ends a voting process by setting its status to ENDED.
+     * This is a simplified method that waits for transaction completion.
      *
-     * @param processId - The process ID
-     * @param voteId - The vote ID
-     * @returns Promise resolving to vote status information
+     * For real-time transaction status updates, use endProcessStream() instead.
+     *
+     * @param processId - The process ID to end
+     * @returns Promise resolving when the process is ended
+     *
+     * @example
+     * ```typescript
+     * await sdk.endProcess("0x1234567890abcdef...");
+     * console.log("Process ended successfully");
+     * ```
      */
-    getVoteStatus(processId: string, voteId: string): Promise<VoteStatusInfo>;
+    endProcess(processId: string): Promise<void>;
     /**
-     * Check if an address has voted in a process
+     * Pauses a voting process by setting its status to PAUSED.
+     * Returns an async generator that yields transaction status events.
      *
-     * @param processId - The process ID
-     * @param address - The voter's address
-     * @returns Promise resolving to boolean indicating if the address has voted
+     * @param processId - The process ID to pause
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.pauseProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("Process paused successfully");
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    pauseProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>>;
+    /**
+     * Pauses a voting process by setting its status to PAUSED.
+     * This is a simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use pauseProcessStream() instead.
+     *
+     * @param processId - The process ID to pause
+     * @returns Promise resolving when the process is paused
+     *
+     * @example
+     * ```typescript
+     * await sdk.pauseProcess("0x1234567890abcdef...");
+     * console.log("Process paused successfully");
+     * ```
+     */
+    pauseProcess(processId: string): Promise<void>;
+    /**
+     * Cancels a voting process by setting its status to CANCELED.
+     * Returns an async generator that yields transaction status events.
+     *
+     * @param processId - The process ID to cancel
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.cancelProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("Process canceled successfully");
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    cancelProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>>;
+    /**
+     * Cancels a voting process by setting its status to CANCELED.
+     * This is a simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use cancelProcessStream() instead.
+     *
+     * @param processId - The process ID to cancel
+     * @returns Promise resolving when the process is canceled
+     *
+     * @example
+     * ```typescript
+     * await sdk.cancelProcess("0x1234567890abcdef...");
+     * console.log("Process canceled successfully");
+     * ```
+     */
+    cancelProcess(processId: string): Promise<void>;
+    /**
+     * Resumes a voting process by setting its status to READY.
+     * This is typically used to resume a paused process.
+     * Returns an async generator that yields transaction status events.
+     *
+     * @param processId - The process ID to resume
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.resumeProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("Process resumed successfully");
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    resumeProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>>;
+    /**
+     * Resumes a voting process by setting its status to READY.
+     * This is typically used to resume a paused process.
+     * This is a simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use resumeProcessStream() instead.
+     *
+     * @param processId - The process ID to resume
+     * @returns Promise resolving when the process is resumed
+     *
+     * @example
+     * ```typescript
+     * await sdk.resumeProcess("0x1234567890abcdef...");
+     * console.log("Process resumed successfully");
+     * ```
+     */
+    resumeProcess(processId: string): Promise<void>;
+}
+
+/**
+ * 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;
+}
+/**
+ * Configuration options for VoteOrchestrationService
+ */
+interface VoteOrchestrationConfig {
+    /** Whether to verify downloaded circuit files match expected hashes (default: true) */
+    verifyCircuitFiles?: boolean;
+    /** Whether to verify the generated proof is valid before submission (default: true) */
+    verifyProof?: boolean;
+}
+/**
+ * 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;
+    private readonly verifyCircuitFiles;
+    private readonly verifyProof;
+    constructor(apiService: VocdoniApiService, getCrypto: () => Promise<DavinciCrypto>, signer: Signer, censusProviders?: CensusProviders, config?: VoteOrchestrationConfig);
+    /**
+     * 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
+     * Watch vote status changes in real-time using an async generator.
+     * Yields each status change as it happens, allowing for reactive UI updates.
+     *
+     * @param processId - The process ID
+     * @param voteId - The vote ID
+     * @param options - Optional configuration
+     * @returns AsyncGenerator yielding vote status updates
+     *
+     * @example
+     * ```typescript
+     * const vote = await sdk.submitVote({ processId, choices: [1] });
+     *
+     * for await (const statusInfo of sdk.watchVoteStatus(vote.processId, vote.voteId)) {
+     *   console.log(`Vote status: ${statusInfo.status}`);
+     *
+     *   switch (statusInfo.status) {
+     *     case VoteStatus.Pending:
+     *       console.log("⏳ Processing...");
+     *       break;
+     *     case VoteStatus.Verified:
+     *       console.log("✓ Verified");
+     *       break;
+     *     case VoteStatus.Settled:
+     *       console.log("✅ Settled");
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    watchVoteStatus(processId: string, voteId: string, options?: {
+        targetStatus?: VoteStatus;
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): AsyncGenerator<VoteStatusInfo>;
+    /**
+     * Wait for a vote to reach a specific status.
+     * This is a simpler alternative to watchVoteStatus() that returns only the final status.
      *
      * @param processId - The process ID
      * @param voteId - The vote ID
@@ -1384,5 +1829,682 @@ declare function signProcessCreation(processId: string, signer: Signer | Wallet)
  */
 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 };
+/**
+ * Configuration interface for the DavinciSDK
+ */
+interface DavinciSDKConfig {
+    /**
+     * Ethers.js Signer for signing operations.
+     * - For voting only: Can be a bare Wallet (no provider needed)
+     * - For process/organization operations: Must be connected to a provider
+     */
+    signer: Signer;
+    /** Sequencer API URL for Vocdoni services (required) */
+    sequencerUrl: string;
+    /** Census API URL for census management (optional, only needed when creating censuses from scratch) */
+    censusUrl?: string;
+    /** Custom contract addresses (optional, fetched from sequencer if not provided) */
+    addresses?: {
+        processRegistry?: string;
+        organizationRegistry?: string;
+        stateTransitionVerifier?: string;
+        resultsVerifier?: string;
+        sequencerRegistry?: string;
+    };
+    /** Custom census proof providers (optional) */
+    censusProviders?: CensusProviders;
+    /** Whether to verify downloaded circuit files match expected hashes (optional, defaults to true) */
+    verifyCircuitFiles?: boolean;
+    /** Whether to verify the generated proof is valid before submission (optional, defaults to true) */
+    verifyProof?: boolean;
+}
+/**
+ * Internal configuration interface
+ */
+interface InternalDavinciSDKConfig {
+    signer: Signer;
+    sequencerUrl: string;
+    censusUrl?: string;
+    customAddresses: {
+        processRegistry?: string;
+        organizationRegistry?: string;
+        stateTransitionVerifier?: string;
+        resultsVerifier?: string;
+        sequencerRegistry?: string;
+    };
+    fetchAddressesFromSequencer: boolean;
+    verifyCircuitFiles: boolean;
+    verifyProof: boolean;
+}
+/**
+ * Simplified SDK class that encapsulates all Vocdoni DaVinci functionality
+ */
+declare class DavinciSDK {
+    private config;
+    private apiService;
+    private _processRegistry?;
+    private _organizationRegistry?;
+    private _processOrchestrator?;
+    private _voteOrchestrator?;
+    private davinciCrypto?;
+    private initialized;
+    private censusProviders;
+    constructor(config: DavinciSDKConfig);
+    /**
+     * Initialize the SDK and all its components
+     * This must be called before using any SDK functionality
+     */
+    init(): Promise<void>;
+    /**
+     * Get the API service for direct access to sequencer and census APIs
+     */
+    get api(): VocdoniApiService;
+    /**
+     * Get the process registry service for process management.
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @throws Error if signer does not have a provider
+     */
+    get processes(): ProcessRegistryService;
+    /**
+     * Get the organization registry service for organization management.
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @throws Error if signer does not have a provider
+     */
+    get organizations(): OrganizationRegistryService;
+    /**
+     * Get or initialize the DavinciCrypto service for cryptographic operations
+     */
+    getCrypto(): Promise<DavinciCrypto>;
+    /**
+     * Get the process orchestration service for simplified process creation.
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @throws Error if signer does not have a provider
+     */
+    get processOrchestrator(): ProcessOrchestrationService;
+    /**
+     * Get the vote orchestration service for simplified voting
+     */
+    get voteOrchestrator(): VoteOrchestrationService;
+    /**
+     * Gets user-friendly process information from the blockchain.
+     * This method fetches raw contract data and transforms it into a user-friendly format
+     * that matches the ProcessConfig interface used for creation, plus additional runtime data.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to fetch
+     * @returns Promise resolving to user-friendly process information
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const processInfo = await sdk.getProcess("0x1234567890abcdef...");
+     *
+     * // Access the same fields as ProcessConfig
+     * console.log("Title:", processInfo.title);
+     * console.log("Description:", processInfo.description);
+     * console.log("Questions:", processInfo.questions);
+     * console.log("Census size:", processInfo.census.size);
+     * console.log("Ballot config:", processInfo.ballot);
+     *
+     * // Plus additional runtime information
+     * console.log("Status:", processInfo.status);
+     * console.log("Creator:", processInfo.creator);
+     * console.log("Start date:", processInfo.startDate);
+     * console.log("End date:", processInfo.endDate);
+     * console.log("Duration:", processInfo.duration, "seconds");
+     * console.log("Time remaining:", processInfo.timeRemaining, "seconds");
+     *
+     * // Access raw contract data if needed
+     * console.log("Raw data:", processInfo.raw);
+     * ```
+     */
+    getProcess(processId: string): Promise<ProcessInfo>;
+    /**
+     * Creates a complete voting process and returns an async generator that yields transaction status events.
+     * This method allows you to monitor the transaction progress in real-time, including pending, completed,
+     * failed, and reverted states.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param config - Simplified process configuration
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.createProcessStream({
+     *   title: "My Election",
+     *   description: "A simple election",
+     *   census: {
+     *     type: CensusOrigin.CensusOriginMerkleTree,
+     *     root: "0x1234...",
+     *     size: 100,
+     *     uri: "ipfs://..."
+     *   },
+     *   ballot: {
+     *     numFields: 2,
+     *     maxValue: "3",
+     *     minValue: "0",
+     *     uniqueValues: false,
+     *     costFromWeight: false,
+     *     costExponent: 10000,
+     *     maxValueSum: "6",
+     *     minValueSum: "0"
+     *   },
+     *   timing: {
+     *     startDate: new Date("2024-12-01T10:00:00Z"),
+     *     duration: 3600 * 24
+     *   },
+     *   questions: [
+     *     {
+     *       title: "What is your favorite color?",
+     *       choices: [
+     *         { title: "Red", value: 0 },
+     *         { title: "Blue", value: 1 }
+     *       ]
+     *     }
+     *   ]
+     * });
+     *
+     * // Monitor transaction progress
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       // Update UI to show pending state
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("Process created:", event.response.processId);
+     *       console.log("Transaction hash:", event.response.transactionHash);
+     *       // Update UI to show success
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       // Update UI to show error
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       // Update UI to show revert reason
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    createProcessStream(config: ProcessConfig): AsyncGenerator<TxStatusEvent<ProcessCreationResult>, any, any>;
+    /**
+     * Creates a complete voting process with minimal configuration.
+     * This is the ultra-easy method for end users that handles all the complex orchestration internally.
+     *
+     * For real-time transaction status updates, use createProcessStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * The method automatically:
+     * - Gets encryption keys and initial state root from the sequencer
+     * - Handles process creation signatures
+     * - Coordinates between sequencer API and on-chain contract calls
+     * - Creates and pushes metadata
+     * - Submits the on-chain transaction
+     *
+     * @param config - Simplified process configuration
+     * @returns Promise resolving to the process creation result
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * // Option 1: Using duration (traditional approach)
+     * const result1 = await sdk.createProcess({
+     *   title: "My Election",
+     *   description: "A simple election",
+     *   census: {
+     *     type: CensusOrigin.CensusOriginMerkleTree,
+     *     root: "0x1234...",
+     *     size: 100,
+     *     uri: "ipfs://your-census-uri"
+     *   },
+     *   ballot: {
+     *     numFields: 2,
+     *     maxValue: "3",
+     *     minValue: "0",
+     *     uniqueValues: false,
+     *     costFromWeight: false,
+     *     costExponent: 10000,
+     *     maxValueSum: "6",
+     *     minValueSum: "0"
+     *   },
+     *   timing: {
+     *     startDate: new Date("2024-12-01T10:00:00Z"),
+     *     duration: 3600 * 24
+     *   },
+     *   questions: [
+     *     {
+     *       title: "What is your favorite color?",
+     *       choices: [
+     *         { title: "Red", value: 0 },
+     *         { title: "Blue", value: 1 }
+     *       ]
+     *     }
+     *   ]
+     * });
+     *
+     * // Option 2: Using start and end dates
+     * const result2 = await sdk.createProcess({
+     *   title: "Weekend Vote",
+     *   timing: {
+     *     startDate: "2024-12-07T09:00:00Z",
+     *     endDate: "2024-12-08T18:00:00Z"
+     *   }
+     * });
+     * ```
+     */
+    createProcess(config: ProcessConfig): Promise<ProcessCreationResult>;
+    /**
+     * Submit a vote with simplified configuration.
+     * This is the ultra-easy method for end users that handles all the complex voting workflow internally.
+     *
+     * Does NOT require a provider - can be used with a bare Wallet for signing only.
+     * IMPORTANT: Requires censusUrl to be configured in the SDK for fetching census proofs (unless using custom census providers).
+     *
+     * The method automatically:
+     * - Fetches process information and validates voting is allowed
+     * - Gets census proof (Merkle tree based)
+     * - Generates cryptographic proofs and encrypts the vote
+     * - Signs and submits the vote to the sequencer
+     *
+     * @param config - Simplified vote configuration
+     * @returns Promise resolving to vote submission result
+     * @throws Error if censusUrl is not configured (unless using custom census providers)
+     *
+     * @example
+     * ```typescript
+     * // Submit a vote with voter's private key
+     * const voteResult = await sdk.submitVote({
+     *   processId: "0x1234567890abcdef...",
+     *   choices: [1, 0], // Vote for option 1 in question 1, option 0 in question 2
+     *   voterKey: "0x1234567890abcdef..." // Voter's private key
+     * });
+     *
+     * console.log("Vote ID:", voteResult.voteId);
+     * console.log("Status:", voteResult.status);
+     *
+     * // Submit a vote with a Wallet instance
+     * import { Wallet } from "ethers";
+     * const voterWallet = new Wallet("0x...");
+     *
+     * const voteResult2 = await sdk.submitVote({
+     *   processId: "0x1234567890abcdef...",
+     *   choices: [2], // Single question vote
+     *   voterKey: voterWallet
+     * });
+     * ```
+     */
+    submitVote(config: VoteConfig): Promise<VoteResult>;
+    /**
+     * Get the status of a submitted vote.
+     *
+     * Does NOT require a provider - uses API calls only.
+     *
+     * @param processId - The process ID
+     * @param voteId - The vote ID returned from submitVote()
+     * @returns Promise resolving to vote status information
+     *
+     * @example
+     * ```typescript
+     * const statusInfo = await sdk.getVoteStatus(processId, voteId);
+     * console.log("Vote status:", statusInfo.status);
+     * // Possible statuses: "pending", "verified", "aggregated", "processed", "settled", "error"
+     * ```
+     */
+    getVoteStatus(processId: string, voteId: string): Promise<VoteStatusInfo>;
+    /**
+     * Check if an address has voted in a process.
+     *
+     * Does NOT require a provider - uses API calls only.
+     *
+     * @param processId - The process ID
+     * @param address - The voter's address
+     * @returns Promise resolving to boolean indicating if the address has voted
+     *
+     * @example
+     * ```typescript
+     * const hasVoted = await sdk.hasAddressVoted(processId, "0x1234567890abcdef...");
+     * if (hasVoted) {
+     *   console.log("This address has already voted");
+     * }
+     * ```
+     */
+    hasAddressVoted(processId: string, address: string): Promise<boolean>;
+    /**
+     * Watch vote status changes in real-time using an async generator.
+     * This method yields each status change as it happens, perfect for showing
+     * progress indicators in UI applications.
+     *
+     * Does NOT require a provider - uses API calls only.
+     *
+     * @param processId - The process ID
+     * @param voteId - The vote ID
+     * @param options - Optional configuration
+     * @returns AsyncGenerator yielding vote status updates
+     *
+     * @example
+     * ```typescript
+     * // Submit vote
+     * const voteResult = await sdk.submitVote({
+     *   processId: "0x1234567890abcdef...",
+     *   choices: [1]
+     * });
+     *
+     * // Watch status changes in real-time
+     * for await (const statusInfo of sdk.watchVoteStatus(voteResult.processId, voteResult.voteId)) {
+     *   console.log(`Vote status: ${statusInfo.status}`);
+     *
+     *   switch (statusInfo.status) {
+     *     case VoteStatus.Pending:
+     *       console.log("⏳ Processing...");
+     *       break;
+     *     case VoteStatus.Verified:
+     *       console.log("✓ Vote verified");
+     *       break;
+     *     case VoteStatus.Aggregated:
+     *       console.log("📊 Vote aggregated");
+     *       break;
+     *     case VoteStatus.Settled:
+     *       console.log("✅ Vote settled");
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    watchVoteStatus(processId: string, voteId: string, options?: {
+        targetStatus?: VoteStatus;
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): AsyncGenerator<VoteStatusInfo, any, any>;
+    /**
+     * Wait for a vote to reach a specific status.
+     * This is a simpler alternative to watchVoteStatus() that returns only the final status.
+     * Useful for waiting for vote confirmation and processing without needing to handle each intermediate status.
+     *
+     * Does NOT require a provider - uses API calls only.
+     *
+     * @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
+     *
+     * @example
+     * ```typescript
+     * // Submit vote and wait for it to be settled
+     * const voteResult = await sdk.submitVote({
+     *   processId: "0x1234567890abcdef...",
+     *   choices: [1]
+     * });
+     *
+     * // Wait for the vote to be fully processed
+     * const finalStatus = await sdk.waitForVoteStatus(
+     *   voteResult.processId,
+     *   voteResult.voteId,
+     *   VoteStatus.Settled, // Wait until vote is settled
+     *   300000,    // 5 minute timeout
+     *   5000       // Check every 5 seconds
+     * );
+     *
+     * console.log("Vote final status:", finalStatus.status);
+     * ```
+     */
+    waitForVoteStatus(processId: string, voteId: string, targetStatus?: VoteStatus, timeoutMs?: number, pollIntervalMs?: number): Promise<VoteStatusInfo>;
+    /**
+     * Ends a voting process by setting its status to ENDED and returns an async generator
+     * that yields transaction status events. This method allows you to monitor the
+     * transaction progress in real-time.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to end
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.endProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("Process ended successfully");
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    endProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, any, any>;
+    /**
+     * Ends a voting process by setting its status to ENDED.
+     * This is the simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use endProcessStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to end
+     * @returns Promise resolving when the process is ended
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * await sdk.endProcess("0x1234567890abcdef...");
+     * console.log("Process ended successfully");
+     * ```
+     */
+    endProcess(processId: string): Promise<void>;
+    /**
+     * Pauses a voting process by setting its status to PAUSED and returns an async generator
+     * that yields transaction status events. This method allows you to monitor the
+     * transaction progress in real-time.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to pause
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.pauseProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("Process paused successfully");
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    pauseProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, any, any>;
+    /**
+     * Pauses a voting process by setting its status to PAUSED.
+     * This is the simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use pauseProcessStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to pause
+     * @returns Promise resolving when the process is paused
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * await sdk.pauseProcess("0x1234567890abcdef...");
+     * console.log("Process paused successfully");
+     * ```
+     */
+    pauseProcess(processId: string): Promise<void>;
+    /**
+     * Cancels a voting process by setting its status to CANCELED and returns an async generator
+     * that yields transaction status events. This method allows you to monitor the
+     * transaction progress in real-time.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to cancel
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.cancelProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("Process canceled successfully");
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    cancelProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, any, any>;
+    /**
+     * Cancels a voting process by setting its status to CANCELED.
+     * This is the simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use cancelProcessStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to cancel
+     * @returns Promise resolving when the process is canceled
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * await sdk.cancelProcess("0x1234567890abcdef...");
+     * console.log("Process canceled successfully");
+     * ```
+     */
+    cancelProcess(processId: string): Promise<void>;
+    /**
+     * Resumes a voting process by setting its status to READY and returns an async generator
+     * that yields transaction status events. This is typically used to resume a paused process.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to resume
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.resumeProcessStream("0x1234567890abcdef...");
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("Process resumed successfully");
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    resumeProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>, any, any>;
+    /**
+     * Resumes a voting process by setting its status to READY.
+     * This is typically used to resume a paused process.
+     * This is the simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use resumeProcessStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID to resume
+     * @returns Promise resolving when the process is resumed
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * await sdk.resumeProcess("0x1234567890abcdef...");
+     * console.log("Process resumed successfully");
+     * ```
+     */
+    resumeProcess(processId: string): Promise<void>;
+    /**
+     * Resolve contract address based on configuration priority:
+     * 1. Custom addresses from user config (if provided)
+     * 2. Addresses from sequencer (fetched during init if no custom addresses provided)
+     */
+    private resolveContractAddress;
+    /**
+     * Fetch contract addresses from sequencer info
+     * This is called during init() if custom addresses are not provided
+     */
+    private fetchContractAddressesFromSequencer;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): Readonly<InternalDavinciSDKConfig>;
+    /**
+     * Check if the SDK has been initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Ensures that the signer has a provider for blockchain operations.
+     * @throws Error if the signer does not have a provider
+     * @private
+     */
+    private ensureProvider;
+}
+
+export { BaseService, Census, CensusOrchestrator, CensusOrigin, CensusType, CircomProof, ContractServiceError, CspCensus, DavinciCrypto, DavinciSDK, ElectionMetadataTemplate, ElectionResultsTypeNames, OrganizationAdministratorError, OrganizationCreateError, OrganizationDeleteError, OrganizationRegistryService, OrganizationUpdateError, PlainCensus, ProcessCensusError, ProcessCreateError, ProcessDurationError, ProcessOrchestrationService, ProcessRegistryService, ProcessResultError, ProcessStateTransitionError, ProcessStatus, ProcessStatusError, PublishedCensus, SmartContractService, TxStatus, VocdoniApiService, VocdoniCensusService, VocdoniSequencerService, VoteOrchestrationService, VoteStatus, WeightedCensus, assertCSPCensusProof, assertMerkleCensusProof, createProcessSignatureMessage, getElectionMetadataTemplate, isCSPCensusProof, isMerkleCensusProof, signProcessCreation, validateProcessId };
+export type { AbstainProperties, AnyJson, ApiError, ApprovalProperties, BallotMode, BaseCensusProof, BaseProcess, BudgetProperties, CSPCensusProof, CSPCensusProofProvider, CSPSignOutput, CensusData, CensusParticipant$1 as CensusParticipant, CensusProof, CensusProviders, CensusSizeResponse, Choice, ChoiceProperties, CircomProofOptions, CreateProcessRequest, CreateProcessResponse, CustomMeta, DavinciCryptoCiphertext, DavinciCryptoInputs, DavinciCryptoOptions, DavinciCryptoOutput, DavinciSDKConfig, ElectionMetadata, ElectionResultsType, EncryptionKey, EntityCallback, GetProcessResponse, Groth16Proof, HealthResponse, IChoice, IQuestion, InfoResponse, JsonArray, JsonMap, ListProcessesResponse, MerkleCensusProof, MerkleCensusProofProvider, MultiLanguage, OrganizationAdministratorAddedCallback, OrganizationAdministratorRemovedCallback, OrganizationCreatedCallback, OrganizationInfo, OrganizationUpdatedCallback, ProcessCensusUpdatedCallback, ProcessConfig, ProcessCreatedCallback, ProcessCreationResult, ProcessDurationChangedCallback, ProcessInfo, ProcessResultsSetCallback, ProcessStateRootUpdatedCallback, ProcessStatusChangedCallback, ProofInputs, ProtocolVersion, PublishCensusResponse, QuadraticProperties, Question, SequencerStats, Snapshot, SnapshotsQueryParams, SnapshotsResponse, TxStatusEvent, VocdoniApiServiceConfig, VoteBallot, VoteCiphertext, VoteConfig, VoteOrchestrationConfig, VoteProof, VoteRequest, VoteResult, VoteStatusInfo, VoteStatusResponse, WeightedParticipant, WorkerStats, WorkersResponse };