@vocdoni/davinci-sdk 0.0.1 → 0.0.2

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;
@@ -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;
@@ -608,9 +628,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 +706,56 @@ 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 (eth_newFilter).
+     *
+     * @param error - The error to check
+     * @returns true if the error indicates unsupported method
+     */
+    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;
 }
 
 /**
@@ -1162,10 +1237,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,6 +1308,200 @@ declare class ProcessOrchestrationService {
      * Creates metadata from the simplified configuration
      */
     private createMetadata;
+    /**
+     * Ends a voting process by setting its status to ENDED.
+     * Returns an async generator that yields transaction status events.
+     *
+     * @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;
+     *   }
+     * }
+     * ```
+     */
+    endProcessStream(processId: string): AsyncGenerator<TxStatusEvent<{
+        success: boolean;
+    }>>;
+    /**
+     * Ends a voting process by setting its status to ENDED.
+     * This is a simplified method that waits for transaction completion.
+     *
+     * 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");
+     * ```
+     */
+    endProcess(processId: string): Promise<void>;
+    /**
+     * Pauses a voting process by setting its status to PAUSED.
+     * Returns an async generator that yields transaction status events.
+     *
+     * @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>;
 }
 
 /**
@@ -1256,7 +1580,43 @@ declare class VoteOrchestrationService {
      */
     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 +1744,686 @@ 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;
+    /** Environment to use (dev, stg, prod) - used to set default URLs and chain if not explicitly provided */
+    environment?: Environment;
+    /** Sequencer API URL for Vocdoni services (optional, defaults based on environment) */
+    sequencerUrl?: string;
+    /** Census API URL for census management (optional, defaults based on environment) */
+    censusUrl?: string;
+    /** Chain name (optional, defaults based on environment) */
+    chain?: 'sepolia' | 'mainnet';
+    /** Custom contract addresses (optional, uses defaults if not provided) */
+    contractAddresses?: {
+        processRegistry?: string;
+        organizationRegistry?: string;
+        stateTransitionVerifier?: string;
+        resultsVerifier?: string;
+        sequencerRegistry?: string;
+    };
+    /** Whether to force using contract addresses from sequencer info (optional, defaults to false) */
+    useSequencerAddresses?: boolean;
+    /** Custom census proof providers (optional) */
+    censusProviders?: CensusProviders;
+}
+/**
+ * Internal configuration interface (without environment)
+ */
+interface InternalDavinciSDKConfig {
+    signer: Signer;
+    sequencerUrl: string;
+    censusUrl: string;
+    chain: 'sepolia' | 'mainnet';
+    contractAddresses: {
+        processRegistry?: string;
+        organizationRegistry?: string;
+        stateTransitionVerifier?: string;
+        resultsVerifier?: string;
+        sequencerRegistry?: string;
+    };
+    useSequencerAddresses: 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.
+     *
+     * 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
+     *
+     * @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. If useSequencerAddresses is true: addresses from sequencer (highest priority)
+     * 2. Custom addresses from config (if provided by user)
+     * 3. Default deployed addresses from npm package
+     */
+    private resolveContractAddress;
+    /**
+     * Get default contract address from deployed addresses
+     */
+    private getDefaultContractAddress;
+    /**
+     * Update contract addresses from sequencer info if useSequencerAddresses is enabled
+     * Sequencer addresses have priority over user-provided addresses
+     */
+    private updateContractAddressesFromSequencer;
+    /**
+     * 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, CensusOrigin, CircomProof, ContractServiceError, DEFAULT_ENVIRONMENT_URLS, DavinciCrypto, DavinciSDK, ElectionMetadataTemplate, ElectionResultsTypeNames, OrganizationAdministratorError, OrganizationCreateError, OrganizationDeleteError, OrganizationRegistryService, OrganizationUpdateError, ProcessCensusError, ProcessCreateError, ProcessDurationError, ProcessOrchestrationService, ProcessRegistryService, ProcessResultError, ProcessStateTransitionError, ProcessStatus, ProcessStatusError, SmartContractService, TxStatus, VocdoniApiService, VocdoniCensusService, VocdoniSequencerService, VoteOrchestrationService, VoteStatus, assertCSPCensusProof, assertMerkleCensusProof, createProcessSignatureMessage, deployedAddresses, getElectionMetadataTemplate, getEnvironmentChain, getEnvironmentConfig, getEnvironmentUrls, isCSPCensusProof, isMerkleCensusProof, resolveConfiguration, resolveUrls, signProcessCreation, validateProcessId };
+export type { AbstainProperties, AnyJson, ApiError, ApprovalProperties, BallotMode, BaseCensusProof, BaseProcess, BudgetProperties, CSPCensusProof, CSPCensusProofProvider, CSPSignOutput, Census, CensusParticipant, CensusProof, CensusProviders, CensusSizeResponse, ChainConfig, Choice, ChoiceProperties, CircomProofOptions, CreateProcessRequest, CreateProcessResponse, CustomMeta, DavinciCryptoCiphertext, DavinciCryptoInputs, DavinciCryptoOptions, DavinciCryptoOutput, DavinciSDKConfig, DeployedAddresses, ElectionMetadata, ElectionResultsType, EncryptionKey, EntityCallback, Environment, EnvironmentConfig, EnvironmentOptions, 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, ServiceUrls, Snapshot, SnapshotsQueryParams, SnapshotsResponse, TxStatusEvent, VocdoniApiServiceConfig, VoteBallot, VoteCiphertext, VoteConfig, VoteProof, VoteRequest, VoteResult, VoteStatusInfo, VoteStatusResponse, WorkerStats, WorkersResponse };