@vocdoni/davinci-sdk 0.0.1 → 0.0.3

package/dist/index.js

@@ -215,6 +215,281 @@ function assertCSPCensusProof(proof) {
   }
 }
 
+var CensusType = /* @__PURE__ */ ((CensusType2) => {
+  CensusType2["PLAIN"] = "plain";
+  CensusType2["WEIGHTED"] = "weighted";
+  CensusType2["CSP"] = "csp";
+  return CensusType2;
+})(CensusType || {});
+class Census {
+  constructor(type) {
+    this._censusId = null;
+    this._censusRoot = null;
+    this._censusURI = null;
+    this._size = null;
+    this._type = type;
+  }
+  get censusId() {
+    return this._censusId;
+  }
+  get censusRoot() {
+    return this._censusRoot;
+  }
+  get censusURI() {
+    return this._censusURI;
+  }
+  get type() {
+    return this._type;
+  }
+  get size() {
+    return this._size;
+  }
+  get isPublished() {
+    return this._censusRoot !== null && this._censusURI !== null;
+  }
+  /**
+   * Convert CensusType to CensusOrigin enum for API compatibility
+   */
+  get censusOrigin() {
+    switch (this._type) {
+      case "plain" /* PLAIN */:
+      case "weighted" /* WEIGHTED */:
+        return CensusOrigin.CensusOriginMerkleTree;
+      case "csp" /* CSP */:
+        return CensusOrigin.CensusOriginCSP;
+      default:
+        throw new Error(`Unknown census type: ${this._type}`);
+    }
+  }
+}
+
+class PlainCensus extends Census {
+  constructor() {
+    super(CensusType.PLAIN);
+    this._participants = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Add participant(s) with automatic weight=1
+   * @param addresses - Single address or array of addresses
+   */
+  add(addresses) {
+    const toAdd = Array.isArray(addresses) ? addresses : [addresses];
+    for (const address of toAdd) {
+      this.validateAddress(address);
+      this._participants.add(address.toLowerCase());
+    }
+  }
+  /**
+   * Remove participant by address
+   */
+  remove(address) {
+    this._participants.delete(address.toLowerCase());
+  }
+  /**
+   * Get all participants as CensusParticipant array (for API)
+   * All participants have weight="1"
+   */
+  get participants() {
+    return Array.from(this._participants).map((key) => ({
+      key,
+      weight: "1"
+      // Everyone has weight=1 in plain census
+    }));
+  }
+  /**
+   * Get addresses only
+   */
+  get addresses() {
+    return Array.from(this._participants);
+  }
+  validateAddress(address) {
+    if (!address || typeof address !== "string") {
+      throw new Error("Address is required and must be a string");
+    }
+    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(address)) {
+      throw new Error(`Invalid Ethereum address format: ${address}`);
+    }
+  }
+  /**
+   * Internal method called after publishing
+   * @internal
+   */
+  _setPublishedData(root, uri, size, censusId) {
+    this._censusRoot = root;
+    this._censusURI = uri;
+    this._size = size;
+    if (censusId) this._censusId = censusId;
+  }
+}
+
+class WeightedCensus extends Census {
+  constructor() {
+    super(CensusType.WEIGHTED);
+    this._participants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 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) {
+    const toAdd = Array.isArray(participant) ? participant : [participant];
+    for (const p of toAdd) {
+      this.validateParticipant(p);
+      const weightString = this.normalizeWeight(p.weight);
+      this._participants.set(p.key.toLowerCase(), weightString);
+    }
+  }
+  /**
+   * Remove participant by address
+   */
+  remove(address) {
+    this._participants.delete(address.toLowerCase());
+  }
+  /**
+   * Get all participants as CensusParticipant array
+   */
+  get participants() {
+    return Array.from(this._participants.entries()).map(([key, weight]) => ({
+      key,
+      weight
+    }));
+  }
+  /**
+   * Get participant addresses
+   */
+  get addresses() {
+    return Array.from(this._participants.keys());
+  }
+  /**
+   * Get weight for specific address
+   */
+  getWeight(address) {
+    return this._participants.get(address.toLowerCase());
+  }
+  /**
+   * Normalizes weight from string, number, or bigint to string
+   */
+  normalizeWeight(weight) {
+    if (typeof weight === "string") {
+      if (!/^\d+$/.test(weight)) {
+        throw new Error(`Invalid weight format: ${weight}. Must be a positive integer.`);
+      }
+      return weight;
+    }
+    if (typeof weight === "number") {
+      if (!Number.isInteger(weight) || weight < 0) {
+        throw new Error(`Invalid weight: ${weight}. Must be a positive integer.`);
+      }
+      return weight.toString();
+    }
+    if (typeof weight === "bigint") {
+      if (weight < 0n) {
+        throw new Error(`Invalid weight: ${weight}. Must be a positive integer.`);
+      }
+      return weight.toString();
+    }
+    throw new Error(`Invalid weight type. Must be string, number, or bigint.`);
+  }
+  validateParticipant(participant) {
+    if (!participant.key || typeof participant.key !== "string") {
+      throw new Error("Participant key (address) is required");
+    }
+    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(participant.key)) {
+      throw new Error(`Invalid Ethereum address format: ${participant.key}`);
+    }
+    if (participant.weight === void 0 || participant.weight === null) {
+      throw new Error("Participant weight is required");
+    }
+  }
+  /**
+   * Internal method called after publishing
+   * @internal
+   */
+  _setPublishedData(root, uri, size, censusId) {
+    this._censusRoot = root;
+    this._censusURI = uri;
+    this._size = size;
+    if (censusId) this._censusId = censusId;
+  }
+}
+
+class CspCensus extends Census {
+  constructor(publicKey, cspURI, size) {
+    super(CensusType.CSP);
+    if (!/^(0x)?[0-9a-fA-F]+$/.test(publicKey)) {
+      throw new Error("Public key is missing or invalid");
+    }
+    try {
+      new URL(cspURI);
+    } catch {
+      throw new Error("CSP URI is missing or invalid");
+    }
+    this._publicKey = publicKey;
+    this._cspURI = cspURI;
+    this._censusRoot = publicKey;
+    this._censusURI = cspURI;
+    this._size = size;
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  get cspURI() {
+    return this._cspURI;
+  }
+}
+
+class PublishedCensus extends Census {
+  constructor(type, root, uri, size) {
+    super(type);
+    this._censusRoot = root;
+    this._censusURI = uri;
+    this._size = size;
+  }
+}
+
+class CensusOrchestrator {
+  constructor(censusService) {
+    this.censusService = censusService;
+  }
+  /**
+   * Publishes a PlainCensus or WeightedCensus
+   * Creates a working census, adds participants, and publishes it
+   */
+  async publish(census) {
+    if (census.isPublished) {
+      throw new Error("Census is already published");
+    }
+    if (census.participants.length === 0) {
+      throw new Error("Cannot publish empty census");
+    }
+    const censusId = await this.censusService.createCensus();
+    await this.censusService.addParticipants(censusId, census.participants);
+    const publishResponse = await this.censusService.publishCensus(censusId);
+    census._setPublishedData(
+      publishResponse.root,
+      publishResponse.uri,
+      publishResponse.participantCount,
+      censusId
+    );
+  }
+  /**
+   * Gets census data for process creation
+   * Throws if census is not published
+   */
+  getCensusData(census) {
+    if (!census.isPublished) {
+      throw new Error("Census must be published before creating a process");
+    }
+    return {
+      type: census.censusOrigin,
+      root: census.censusRoot,
+      uri: census.censusURI,
+      size: census.size
+    };
+  }
+}
+
 function createProcessSignatureMessage(processId) {
   const cleanProcessId = processId.replace(/^0x/, "").toLowerCase();
   return `I am creating a new voting process for the davinci.vote protocol identified with id ${cleanProcessId}`;
@@ -305,11 +580,15 @@ class VocdoniSequencerService extends BaseService {
       try {
         const response = await fetch(hashOrUrl);
         if (!response.ok) {
-          throw new Error(`Failed to fetch metadata from URL: ${response.status} ${response.statusText}`);
+          throw new Error(
+            `Failed to fetch metadata from URL: ${response.status} ${response.statusText}`
+          );
         }
         return await response.json();
       } catch (error) {
-        throw new Error(`Failed to fetch metadata from URL: ${error instanceof Error ? error.message : "Unknown error"}`);
+        throw new Error(
+          `Failed to fetch metadata from URL: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
       }
     }
     if (!isHexString(hashOrUrl)) {
@@ -345,96 +624,6 @@ class VocdoniApiService {
   }
 }
 
-const DEFAULT_ENVIRONMENT_URLS = {
-  dev: {
-    sequencer: "https://sequencer-dev.davinci.vote",
-    census: "https://c3-dev.davinci.vote",
-    chain: "sepolia"
-  },
-  stg: {
-    sequencer: "https://sequencer1.davinci.vote",
-    census: "https://c3.davinci.vote",
-    chain: "sepolia"
-  },
-  prod: {
-    // TODO: Add production URLs when available
-    sequencer: "",
-    census: "",
-    chain: "mainnet"
-  }
-};
-function getEnvironmentConfig(environment) {
-  return DEFAULT_ENVIRONMENT_URLS[environment];
-}
-function getEnvironmentUrls(environment) {
-  const config = DEFAULT_ENVIRONMENT_URLS[environment];
-  return {
-    sequencer: config.sequencer,
-    census: config.census
-  };
-}
-function getEnvironmentChain(environment) {
-  return DEFAULT_ENVIRONMENT_URLS[environment].chain;
-}
-function resolveConfiguration(options = {}) {
-  const environment = options.environment || "prod";
-  const defaultConfig = getEnvironmentConfig(environment);
-  const resolvedConfig = { ...defaultConfig };
-  if (options.customUrls) {
-    if (options.customUrls.sequencer !== void 0) {
-      resolvedConfig.sequencer = options.customUrls.sequencer;
-    }
-    if (options.customUrls.census !== void 0) {
-      resolvedConfig.census = options.customUrls.census;
-    }
-  }
-  if (options.customChain) {
-    resolvedConfig.chain = options.customChain;
-  }
-  return resolvedConfig;
-}
-function resolveUrls(options = {}) {
-  const config = resolveConfiguration(options);
-  return {
-    sequencer: config.sequencer,
-    census: config.census
-  };
-}
-
-var processRegistry = {
-	sepolia: "0x40939Ec9FD872eb79A1723B559572dfD71a05d11",
-	uzh: "0x69B16f67Bd2fB18bD720379E9C1Ef5EaD3872d67",
-	mainnet: "0x0"
-};
-var organizationRegistry = {
-	sepolia: "0xe7136ED5a7b0e995A8fe35d8B1B815E4160cB491",
-	uzh: "0xf7BCE4546805547bE526Ca864d6722Ed193E51Aa",
-	mainnet: "0x0"
-};
-var stateTransitionVerifierGroth16 = {
-	sepolia: "0xb7A142D24b9220eCBC4f7fcB89Ee952a6C7E332a",
-	uzh: "0x5e4673CD378F05cc3Ae25804539c91E711548741",
-	mainnet: "0x0"
-};
-var resultsVerifierGroth16 = {
-	sepolia: "0x1188cEbB56ecc90e2bAe5c914274C81Fe1a22e67",
-	uzh: "0x00c7F87731346F592197E49A90Ad6EC236Ad9985",
-	mainnet: "0x0"
-};
-var sequencerRegistry = {
-	sepolia: "0x0",
-	uzh: "0x0",
-	mainnet: "0x0"
-};
-var addressesJson = {
-	processRegistry: processRegistry,
-	organizationRegistry: organizationRegistry,
-	stateTransitionVerifierGroth16: stateTransitionVerifierGroth16,
-	resultsVerifierGroth16: resultsVerifierGroth16,
-	sequencerRegistry: sequencerRegistry
-};
-
-const deployedAddresses = addressesJson;
 var TxStatus = /* @__PURE__ */ ((TxStatus2) => {
   TxStatus2["Pending"] = "pending";
   TxStatus2["Completed"] = "completed";
@@ -443,23 +632,29 @@ var TxStatus = /* @__PURE__ */ ((TxStatus2) => {
   return TxStatus2;
 })(TxStatus || {});
 class SmartContractService {
+  constructor() {
+    /** Active polling intervals for event listeners using fallback mode */
+    this.pollingIntervals = [];
+    /** Default polling interval in milliseconds for event listener fallback */
+    this.eventPollingInterval = 5e3;
+  }
   /**
    * Sends a transaction and yields status events during its lifecycle.
    * This method handles the complete transaction flow from submission to completion,
    * including error handling and status updates.
-   * 
+   *
    * @template T - The type of the successful response data
    * @param txPromise - Promise resolving to the transaction response
    * @param responseHandler - Function to process the successful transaction result
    * @returns AsyncGenerator yielding transaction status events
-   * 
+   *
    * @example
    * ```typescript
    * const txStream = await this.sendTx(
    *   contract.someMethod(),
    *   async () => await contract.getUpdatedValue()
    * );
-   * 
+   *
    * for await (const event of txStream) {
    *   switch (event.status) {
    *     case TxStatus.Pending:
@@ -496,12 +691,12 @@ class SmartContractService {
    * Executes a transaction stream and returns the result or throws an error.
    * This is a convenience method that processes a transaction stream and either
    * returns the successful result or throws an appropriate error.
-   * 
+   *
    * @template T - The type of the successful response data
    * @param stream - AsyncGenerator of transaction status events
    * @returns Promise resolving to the successful response data
    * @throws Error if the transaction fails or reverts
-   * 
+   *
    * @example
    * ```typescript
    * try {
@@ -531,11 +726,11 @@ class SmartContractService {
    * Normalizes event listener arguments between different ethers.js versions.
    * This helper method ensures consistent event argument handling regardless of
    * whether the event payload follows ethers v5 or v6 format.
-   * 
+   *
    * @template Args - Tuple type representing the expected event arguments
    * @param callback - The event callback function to normalize
    * @returns Normalized event listener function
-   * 
+   *
    * @example
    * ```typescript
    * contract.on('Transfer', this.normalizeListener((from: string, to: string, amount: BigInt) => {
@@ -554,12 +749,153 @@ class SmartContractService {
       callback(...args);
     };
   }
+  /**
+   * 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}`);
+   *   }
+   * );
+   * ```
+   */
+  async setupEventListener(contract, eventFilter, callback) {
+    const normalizedCallback = this.normalizeListener(callback);
+    const provider = contract.runner?.provider;
+    if (!provider) {
+      console.warn("No provider available for event listeners");
+      return;
+    }
+    try {
+      const testFilter = {
+        address: await contract.getAddress(),
+        topics: []
+      };
+      if ("send" in provider && typeof provider.send === "function") {
+        try {
+          const filterId = await provider.send("eth_newFilter", [testFilter]);
+          await provider.send("eth_getFilterChanges", [filterId]);
+          contract.on(eventFilter, normalizedCallback);
+          return;
+        } catch (error) {
+          if (this.isUnsupportedMethodError(error)) {
+            console.warn(
+              "RPC does not fully support eth_newFilter/eth_getFilterChanges, falling back to polling for events. This may result in delayed event notifications."
+            );
+            this.setupPollingListener(contract, eventFilter, callback);
+            return;
+          }
+        }
+      }
+      const errorHandler = (error) => {
+        if (this.isUnsupportedMethodError(error)) {
+          contract.off(eventFilter, normalizedCallback);
+          contract.off("error", errorHandler);
+          console.warn(
+            "RPC does not support eth_newFilter, falling back to polling for events. This may result in delayed event notifications."
+          );
+          this.setupPollingListener(contract, eventFilter, callback);
+        }
+      };
+      contract.once("error", errorHandler);
+      contract.on(eventFilter, normalizedCallback);
+    } catch (error) {
+      console.warn("Error setting up event listener, falling back to polling:", error.message);
+      this.setupPollingListener(contract, eventFilter, callback);
+    }
+  }
+  /**
+   * 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
+   */
+  isUnsupportedMethodError(error) {
+    const isMethodNotFound = error?.code === -32601 || error?.error?.code === -32601 || error?.data?.code === -32601 || typeof error?.message === "string" && error.message.includes("unsupported method");
+    const isFilterNotFound = (error?.code === -32e3 || error?.error?.code === -32e3 || error?.code === "UNKNOWN_ERROR" && error?.error?.code === -32e3) && (error?.message?.includes("filter not found") || error?.error?.message?.includes("filter not found"));
+    return isMethodNotFound || isFilterNotFound;
+  }
+  /**
+   * 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
+   */
+  setupPollingListener(contract, eventFilter, callback) {
+    let lastProcessedBlock = 0;
+    const poll = async () => {
+      try {
+        const provider = contract.runner?.provider;
+        if (!provider) {
+          console.warn("No provider available for polling events");
+          return;
+        }
+        const currentBlock = await provider.getBlockNumber();
+        if (lastProcessedBlock === 0) {
+          lastProcessedBlock = currentBlock - 1;
+        }
+        if (currentBlock > lastProcessedBlock) {
+          const events = await contract.queryFilter(
+            eventFilter,
+            lastProcessedBlock + 1,
+            currentBlock
+          );
+          for (const event of events) {
+            if ("args" in event && event.args) {
+              callback(...event.args);
+            }
+          }
+          lastProcessedBlock = currentBlock;
+        }
+      } catch (error) {
+        console.error("Error polling for events:", error);
+      }
+    };
+    const intervalId = setInterval(poll, this.eventPollingInterval);
+    this.pollingIntervals.push(intervalId);
+    poll();
+  }
+  /**
+   * Clears all active polling intervals.
+   * Should be called when removing all listeners or cleaning up the service.
+   */
+  clearPollingIntervals() {
+    for (const intervalId of this.pollingIntervals) {
+      clearInterval(intervalId);
+    }
+    this.pollingIntervals = [];
+  }
+  /**
+   * Sets the polling interval for event listeners using the fallback mechanism.
+   *
+   * @param intervalMs - Polling interval in milliseconds
+   */
+  setEventPollingInterval(intervalMs) {
+    this.eventPollingInterval = intervalMs;
+  }
 }
 
 class ContractServiceError extends Error {
   /**
    * Creates a new ContractServiceError instance.
-   * 
+   *
    * @param message - The error message describing what went wrong
    * @param operation - The operation that was being performed when the error occurred
    */
@@ -712,7 +1048,7 @@ class ProcessRegistryService extends SmartContractService {
   }
   /**
    * Sets the results for a voting process.
-   * 
+   *
    * @param processID - The ID of the process to set results for
    * @param proof - Zero-knowledge proof validating the results
    * @param input - Input data for the proof verification
@@ -720,11 +1056,7 @@ class ProcessRegistryService extends SmartContractService {
    */
   setProcessResults(processID, proof, input) {
     return this.sendTx(
-      this.contract.setProcessResults(
-        processID,
-        proof,
-        input
-      ).catch((e) => {
+      this.contract.setProcessResults(processID, proof, input).catch((e) => {
         throw new ProcessResultError(e.message, "setResults");
       }),
       async () => ({ success: true })
@@ -732,43 +1064,50 @@ class ProcessRegistryService extends SmartContractService {
   }
   // ─── EVENT LISTENERS ───────────────────────────────────────────────────────
   onProcessCreated(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.ProcessCreated(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up ProcessCreated listener:", err));
   }
   onProcessStatusChanged(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.ProcessStatusChanged(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up ProcessStatusChanged listener:", err));
   }
   onCensusUpdated(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.CensusUpdated(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up CensusUpdated listener:", err));
   }
   onProcessDurationChanged(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.ProcessDurationChanged(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up ProcessDurationChanged listener:", err));
   }
   onStateRootUpdated(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.ProcessStateRootUpdated(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up StateRootUpdated listener:", err));
   }
   onProcessResultsSet(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.ProcessResultsSet(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up ProcessResultsSet listener:", err));
   }
   removeAllListeners() {
     this.contract.removeAllListeners();
+    this.clearPollingIntervals();
   }
 }
 
@@ -779,6 +1118,34 @@ class ProcessOrchestrationService {
     this.organizationRegistry = organizationRegistry;
     this.getCrypto = getCrypto;
     this.signer = signer;
+    this.censusOrchestrator = new CensusOrchestrator(apiService.census);
+  }
+  /**
+   * Handles census - auto-publishes if needed and returns census config
+   * @private
+   */
+  async handleCensus(census) {
+    if ("isPublished" in census) {
+      if (census instanceof PlainCensus || census instanceof WeightedCensus) {
+        if (!census.isPublished) {
+          const censusBaseURL = this.apiService.census?.["axios"]?.defaults?.baseURL;
+          if (!censusBaseURL || censusBaseURL === "" || censusBaseURL === "undefined") {
+            throw new Error(
+              'Census API URL is required to publish PlainCensus or WeightedCensus. Please provide "censusUrl" when initializing DavinciSDK, or use a pre-published census.'
+            );
+          }
+          await this.censusOrchestrator.publish(census);
+        }
+      }
+      const censusData = this.censusOrchestrator.getCensusData(census);
+      return {
+        type: censusData.type,
+        root: censusData.root,
+        size: censusData.size,
+        uri: censusData.uri
+      };
+    }
+    return census;
   }
   /**
    * Gets user-friendly process information by transforming raw contract data
@@ -852,14 +1219,119 @@ class ProcessOrchestrationService {
     };
   }
   /**
-   * 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;
+   *   }
+   * }
+   * ```
+   */
+  async *createProcessStream(config) {
+    const data = await this.prepareProcessCreation(config);
+    const encryptionKey = {
+      x: data.sequencerResult.encryptionPubKey[0],
+      y: data.sequencerResult.encryptionPubKey[1]
+    };
+    const txStream = this.processRegistry.newProcess(
+      ProcessStatus.READY,
+      data.startTime,
+      data.duration,
+      data.ballotMode,
+      data.census,
+      data.metadataUri,
+      encryptionKey,
+      BigInt(data.sequencerResult.stateRoot)
+    );
+    let transactionHash = "unknown";
+    for await (const event of txStream) {
+      if (event.status === TxStatus.Pending) {
+        transactionHash = event.hash;
+        yield { status: TxStatus.Pending, hash: event.hash };
+      } else if (event.status === TxStatus.Completed) {
+        yield {
+          status: TxStatus.Completed,
+          response: {
+            processId: data.processId,
+            transactionHash
+          }
+        };
+        break;
+      } else if (event.status === TxStatus.Failed) {
+        yield { status: TxStatus.Failed, error: event.error };
+        break;
+      } else if (event.status === TxStatus.Reverted) {
+        yield { status: TxStatus.Reverted, reason: event.reason };
+        break;
+      }
+    }
+  }
+  /**
+   * 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
    */
   async createProcess(config) {
+    for await (const event of this.createProcessStream(config)) {
+      if (event.status === "completed") {
+        return event.response;
+      } else if (event.status === "failed") {
+        throw event.error;
+      } else if (event.status === "reverted") {
+        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("Process creation stream ended unexpectedly");
+  }
+  /**
+   * Prepares all data needed for process creation
+   * @private
+   */
+  async prepareProcessCreation(config) {
     const { startTime, duration } = this.calculateTiming(config.timing);
     const signerAddress = await this.signer.getAddress();
     const processId = await this.processRegistry.getNextProcessId(signerAddress);
-    const censusRoot = config.census.root;
+    const censusConfig = await this.handleCensus(config.census);
+    const censusRoot = censusConfig.root;
     const ballotMode = config.ballot;
     const metadata = this.createMetadata(config);
     const metadataHash = await this.apiService.sequencer.pushMetadata(metadata);
@@ -870,43 +1342,23 @@ class ProcessOrchestrationService {
       censusRoot,
       ballotMode,
       signature,
-      censusOrigin: config.census.type
+      censusOrigin: censusConfig.type
     });
     const census = {
-      censusOrigin: config.census.type,
-      maxVotes: config.census.size.toString(),
+      censusOrigin: censusConfig.type,
+      maxVotes: censusConfig.size.toString(),
       censusRoot,
-      censusURI: config.census.uri
+      censusURI: censusConfig.uri
     };
-    const encryptionKey = {
-      x: sequencerResult.encryptionPubKey[0],
-      y: sequencerResult.encryptionPubKey[1]
-    };
-    const txStream = this.processRegistry.newProcess(
-      ProcessStatus.READY,
+    return {
+      processId,
       startTime,
       duration,
+      censusRoot,
       ballotMode,
-      census,
       metadataUri,
-      encryptionKey,
-      BigInt(sequencerResult.stateRoot)
-    );
-    let transactionHash = "unknown";
-    for await (const event of txStream) {
-      if (event.status === "pending") {
-        transactionHash = event.hash;
-      } else if (event.status === "completed") {
-        break;
-      } else if (event.status === "failed") {
-        throw event.error;
-      } else if (event.status === "reverted") {
-        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
-      }
-    }
-    return {
-      processId,
-      transactionHash
+      sequencerResult,
+      census
     };
   }
   /**
@@ -972,17 +1424,323 @@ class ProcessOrchestrationService {
     if (!config.questions || config.questions.length === 0) {
       throw new Error("Questions are required. Please provide at least one question with choices.");
     }
-    metadata.questions = config.questions.map((q) => ({
-      title: { default: q.title },
-      description: { default: q.description || "" },
-      meta: {},
-      choices: q.choices.map((c) => ({
-        title: { default: c.title },
-        value: c.value,
-        meta: {}
-      }))
-    }));
-    return metadata;
+    metadata.questions = config.questions.map((q) => ({
+      title: { default: q.title },
+      description: { default: q.description || "" },
+      meta: {},
+      choices: q.choices.map((c) => ({
+        title: { default: c.title },
+        value: c.value,
+        meta: {}
+      }))
+    }));
+    return metadata;
+  }
+  /**
+   * 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;
+   *   }
+   * }
+   * ```
+   */
+  async *endProcessStream(processId) {
+    const txStream = this.processRegistry.setProcessStatus(processId, ProcessStatus.ENDED);
+    for await (const event of txStream) {
+      if (event.status === TxStatus.Pending) {
+        yield { status: TxStatus.Pending, hash: event.hash };
+      } else if (event.status === TxStatus.Completed) {
+        yield {
+          status: TxStatus.Completed,
+          response: { success: true }
+        };
+        break;
+      } else if (event.status === TxStatus.Failed) {
+        yield { status: TxStatus.Failed, error: event.error };
+        break;
+      } else if (event.status === TxStatus.Reverted) {
+        yield { status: TxStatus.Reverted, reason: event.reason };
+        break;
+      }
+    }
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async endProcess(processId) {
+    for await (const event of this.endProcessStream(processId)) {
+      if (event.status === "completed") {
+        return;
+      } else if (event.status === "failed") {
+        throw event.error;
+      } else if (event.status === "reverted") {
+        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("End process stream ended unexpectedly");
+  }
+  /**
+   * 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;
+   *   }
+   * }
+   * ```
+   */
+  async *pauseProcessStream(processId) {
+    const txStream = this.processRegistry.setProcessStatus(processId, ProcessStatus.PAUSED);
+    for await (const event of txStream) {
+      if (event.status === TxStatus.Pending) {
+        yield { status: TxStatus.Pending, hash: event.hash };
+      } else if (event.status === TxStatus.Completed) {
+        yield {
+          status: TxStatus.Completed,
+          response: { success: true }
+        };
+        break;
+      } else if (event.status === TxStatus.Failed) {
+        yield { status: TxStatus.Failed, error: event.error };
+        break;
+      } else if (event.status === TxStatus.Reverted) {
+        yield { status: TxStatus.Reverted, reason: event.reason };
+        break;
+      }
+    }
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async pauseProcess(processId) {
+    for await (const event of this.pauseProcessStream(processId)) {
+      if (event.status === "completed") {
+        return;
+      } else if (event.status === "failed") {
+        throw event.error;
+      } else if (event.status === "reverted") {
+        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("Pause process stream ended unexpectedly");
+  }
+  /**
+   * 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;
+   *   }
+   * }
+   * ```
+   */
+  async *cancelProcessStream(processId) {
+    const txStream = this.processRegistry.setProcessStatus(processId, ProcessStatus.CANCELED);
+    for await (const event of txStream) {
+      if (event.status === TxStatus.Pending) {
+        yield { status: TxStatus.Pending, hash: event.hash };
+      } else if (event.status === TxStatus.Completed) {
+        yield {
+          status: TxStatus.Completed,
+          response: { success: true }
+        };
+        break;
+      } else if (event.status === TxStatus.Failed) {
+        yield { status: TxStatus.Failed, error: event.error };
+        break;
+      } else if (event.status === TxStatus.Reverted) {
+        yield { status: TxStatus.Reverted, reason: event.reason };
+        break;
+      }
+    }
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async cancelProcess(processId) {
+    for await (const event of this.cancelProcessStream(processId)) {
+      if (event.status === "completed") {
+        return;
+      } else if (event.status === "failed") {
+        throw event.error;
+      } else if (event.status === "reverted") {
+        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("Cancel process stream ended unexpectedly");
+  }
+  /**
+   * 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;
+   *   }
+   * }
+   * ```
+   */
+  async *resumeProcessStream(processId) {
+    const txStream = this.processRegistry.setProcessStatus(processId, ProcessStatus.READY);
+    for await (const event of txStream) {
+      if (event.status === TxStatus.Pending) {
+        yield { status: TxStatus.Pending, hash: event.hash };
+      } else if (event.status === TxStatus.Completed) {
+        yield {
+          status: TxStatus.Completed,
+          response: { success: true }
+        };
+        break;
+      } else if (event.status === TxStatus.Failed) {
+        yield { status: TxStatus.Failed, error: event.error };
+        break;
+      } else if (event.status === TxStatus.Reverted) {
+        yield { status: TxStatus.Reverted, reason: event.reason };
+        break;
+      }
+    }
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async resumeProcess(processId) {
+    for await (const event of this.resumeProcessStream(processId)) {
+      if (event.status === "completed") {
+        return;
+      } else if (event.status === "failed") {
+        throw event.error;
+      } else if (event.status === "reverted") {
+        throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("Resume process stream ended unexpectedly");
   }
 }
 
@@ -1053,11 +1811,7 @@ class CircomProof {
       }
       this.zkeyCache.set(zkeyUrl, zkeyBin);
     }
-    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
-      inputs,
-      wasmBin,
-      zkeyBin
-    );
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(inputs, wasmBin, zkeyBin);
     return {
       proof,
       publicSignals
@@ -1092,11 +1846,13 @@ var VoteStatus = /* @__PURE__ */ ((VoteStatus2) => {
 })(VoteStatus || {});
 
 class VoteOrchestrationService {
-  constructor(apiService, getCrypto, signer, censusProviders = {}) {
+  constructor(apiService, getCrypto, signer, censusProviders = {}, config = {}) {
     this.apiService = apiService;
     this.getCrypto = getCrypto;
     this.signer = signer;
     this.censusProviders = censusProviders;
+    this.verifyCircuitFiles = config.verifyCircuitFiles ?? true;
+    this.verifyProof = config.verifyProof ?? true;
   }
   /**
    * Submit a vote with simplified configuration
@@ -1105,7 +1861,7 @@ class VoteOrchestrationService {
    * - 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
    */
@@ -1153,7 +1909,7 @@ class VoteOrchestrationService {
   }
   /**
    * Get the status of a submitted vote
-   * 
+   *
    * @param processId - The process ID
    * @param voteId - The vote ID
    * @returns Promise resolving to vote status information
@@ -1168,7 +1924,7 @@ class VoteOrchestrationService {
   }
   /**
    * 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
@@ -1177,26 +1933,79 @@ class VoteOrchestrationService {
     return this.apiService.sequencer.hasAddressVoted(processId, address);
   }
   /**
-   * 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 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
+   * @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;
+   *   }
+   * }
+   * ```
    */
-  async waitForVoteStatus(processId, voteId, targetStatus = VoteStatus.Settled, timeoutMs = 3e5, pollIntervalMs = 5e3) {
+  async *watchVoteStatus(processId, voteId, options) {
+    const targetStatus = options?.targetStatus ?? VoteStatus.Settled;
+    const timeoutMs = options?.timeoutMs ?? 3e5;
+    const pollIntervalMs = options?.pollIntervalMs ?? 5e3;
     const startTime = Date.now();
+    let previousStatus = null;
     while (Date.now() - startTime < timeoutMs) {
       const statusInfo = await this.getVoteStatus(processId, voteId);
-      if (statusInfo.status === targetStatus || statusInfo.status === VoteStatus.Error) {
-        return statusInfo;
+      if (statusInfo.status !== previousStatus) {
+        previousStatus = statusInfo.status;
+        yield statusInfo;
+        if (statusInfo.status === targetStatus || statusInfo.status === VoteStatus.Error) {
+          return;
+        }
       }
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
     throw new Error(`Vote did not reach status ${targetStatus} within ${timeoutMs}ms`);
   }
+  /**
+   * 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
+   * @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
+   */
+  async waitForVoteStatus(processId, voteId, targetStatus = VoteStatus.Settled, timeoutMs = 3e5, pollIntervalMs = 5e3) {
+    let finalStatus = null;
+    for await (const statusInfo of this.watchVoteStatus(processId, voteId, {
+      targetStatus,
+      timeoutMs,
+      pollIntervalMs
+    })) {
+      finalStatus = statusInfo;
+    }
+    if (!finalStatus) {
+      throw new Error(`Vote did not reach status ${targetStatus} within ${timeoutMs}ms`);
+    }
+    return finalStatus;
+  }
   /**
    * Get census proof based on census origin type
    */
@@ -1278,12 +2087,20 @@ class VoteOrchestrationService {
     const circomProof = new CircomProof({
       wasmUrl: info.circuitUrl,
       zkeyUrl: info.provingKeyUrl,
-      vkeyUrl: info.verificationKeyUrl
+      vkeyUrl: info.verificationKeyUrl,
+      // Only pass hashes if verifyCircuitFiles is enabled
+      ...this.verifyCircuitFiles && {
+        wasmHash: info.circuitHash,
+        zkeyHash: info.provingKeyHash,
+        vkeyHash: info.verificationKeyHash
+      }
     });
     const { proof, publicSignals } = await circomProof.generate(circomInputs);
-    const isValid = await circomProof.verify(proof, publicSignals);
-    if (!isValid) {
-      throw new Error("Generated proof is invalid");
+    if (this.verifyProof) {
+      const isValid = await circomProof.verify(proof, publicSignals);
+      if (!isValid) {
+        throw new Error("Generated proof is invalid");
+      }
     }
     return { proof, publicSignals };
   }
@@ -1321,10 +2138,7 @@ class VoteOrchestrationService {
 class OrganizationRegistryService extends SmartContractService {
   constructor(contractAddress, runner) {
     super();
-    this.contract = davinciContracts.OrganizationRegistry__factory.connect(
-      contractAddress,
-      runner
-    );
+    this.contract = davinciContracts.OrganizationRegistry__factory.connect(contractAddress, runner);
   }
   // ─── READ OPERATIONS ───────────────────────────────────────────────────────
   async getOrganization(id) {
@@ -1384,31 +2198,36 @@ class OrganizationRegistryService extends SmartContractService {
   }
   // ─── EVENT LISTENERS ───────────────────────────────────────────────────────
   onOrganizationCreated(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.OrganizationCreated(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up OrganizationCreated listener:", err));
   }
   onOrganizationUpdated(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.OrganizationUpdated(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up OrganizationUpdated listener:", err));
   }
   onAdministratorAdded(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.AdministratorAdded(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up AdministratorAdded listener:", err));
   }
   onAdministratorRemoved(cb) {
-    this.contract.on(
+    this.setupEventListener(
+      this.contract,
       this.contract.filters.AdministratorRemoved(),
-      this.normalizeListener(cb)
-    );
+      cb
+    ).catch((err) => console.error("Error setting up AdministratorRemoved listener:", err));
   }
   removeAllListeners() {
     this.contract.removeAllListeners();
+    this.clearPollingIntervals();
   }
 }
 
@@ -1595,25 +2414,23 @@ class DavinciCrypto {
 class DavinciSDK {
   constructor(config) {
     this.initialized = false;
-    const resolvedConfig = resolveConfiguration({
-      environment: config.environment,
-      customUrls: {
-        sequencer: config.sequencerUrl,
-        census: config.censusUrl
-      },
-      customChain: config.chain
-    });
+    const hasCustomAddresses = !!config.addresses && Object.keys(config.addresses).length > 0;
     this.config = {
       signer: config.signer,
-      sequencerUrl: config.sequencerUrl ?? resolvedConfig.sequencer,
-      censusUrl: config.censusUrl ?? resolvedConfig.census,
-      chain: config.chain ?? resolvedConfig.chain,
-      contractAddresses: config.contractAddresses || {},
-      useSequencerAddresses: config.useSequencerAddresses || false
+      sequencerUrl: config.sequencerUrl,
+      censusUrl: config.censusUrl,
+      customAddresses: config.addresses || {},
+      fetchAddressesFromSequencer: !hasCustomAddresses,
+      // Automatic: fetch if no custom addresses
+      verifyCircuitFiles: config.verifyCircuitFiles ?? true,
+      // Default to true for security
+      verifyProof: config.verifyProof ?? true
+      // Default to true for security
     };
     this.apiService = new VocdoniApiService({
       sequencerURL: this.config.sequencerUrl,
-      censusURL: this.config.censusUrl
+      censusURL: this.config.censusUrl || ""
+      // Use empty string if not provided
     });
     this.censusProviders = config.censusProviders || {};
   }
@@ -1623,9 +2440,10 @@ class DavinciSDK {
    */
   async init() {
     if (this.initialized) return;
-    if (this.config.useSequencerAddresses) {
-      await this.updateContractAddressesFromSequencer();
+    if (this.config.fetchAddressesFromSequencer) {
+      await this.fetchContractAddressesFromSequencer();
     }
+    if (!this.config.censusUrl) ;
     this.initialized = true;
   }
   /**
@@ -1635,22 +2453,36 @@ class DavinciSDK {
     return this.apiService;
   }
   /**
-   * Get the process registry service for process management
+   * 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() {
+    this.ensureProvider();
     if (!this._processRegistry) {
       const processRegistryAddress = this.resolveContractAddress("processRegistry");
-      this._processRegistry = new ProcessRegistryService(processRegistryAddress, this.config.signer);
+      this._processRegistry = new ProcessRegistryService(
+        processRegistryAddress,
+        this.config.signer
+      );
     }
     return this._processRegistry;
   }
   /**
-   * Get the organization registry service for organization management
+   * 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() {
+    this.ensureProvider();
     if (!this._organizationRegistry) {
       const organizationRegistryAddress = this.resolveContractAddress("organizationRegistry");
-      this._organizationRegistry = new OrganizationRegistryService(organizationRegistryAddress, this.config.signer);
+      this._organizationRegistry = new OrganizationRegistryService(
+        organizationRegistryAddress,
+        this.config.signer
+      );
     }
     return this._organizationRegistry;
   }
@@ -1669,9 +2501,13 @@ class DavinciSDK {
     return this.davinciCrypto;
   }
   /**
-   * Get the process orchestration service for simplified process creation
+   * 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() {
+    this.ensureProvider();
     if (!this._processOrchestrator) {
       this._processOrchestrator = new ProcessOrchestrationService(
         this.processes,
@@ -1692,7 +2528,11 @@ class DavinciSDK {
         this.apiService,
         () => this.getCrypto(),
         this.config.signer,
-        this.censusProviders
+        this.censusProviders,
+        {
+          verifyCircuitFiles: this.config.verifyCircuitFiles,
+          verifyProof: this.config.verifyProof
+        }
       );
     }
     return this._voteOrchestrator;
@@ -1701,21 +2541,24 @@ class DavinciSDK {
    * 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);
@@ -1723,7 +2566,7 @@ class DavinciSDK {
    * 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);
    * ```
@@ -1732,22 +2575,106 @@ class DavinciSDK {
     if (!this.initialized) {
       throw new Error("SDK must be initialized before getting processes. Call sdk.init() first.");
     }
+    this.ensureProvider();
     return this.processOrchestrator.getProcess(processId);
   }
+  /**
+   * 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) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before creating processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.createProcessStream(config);
+  }
   /**
    * 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)
@@ -1784,7 +2711,7 @@ class DavinciSDK {
    *     }
    *   ]
    * });
-   * 
+   *
    * // Option 2: Using start and end dates
    * const result2 = await sdk.createProcess({
    *   title: "Weekend Vote",
@@ -1799,21 +2726,26 @@ class DavinciSDK {
     if (!this.initialized) {
       throw new Error("SDK must be initialized before creating processes. Call sdk.init() first.");
     }
+    this.ensureProvider();
     return this.processOrchestrator.createProcess(config);
   }
   /**
    * 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
@@ -1822,14 +2754,14 @@ class DavinciSDK {
    *   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
@@ -1841,15 +2773,22 @@ class DavinciSDK {
     if (!this.initialized) {
       throw new Error("SDK must be initialized before submitting votes. Call sdk.init() first.");
     }
+    if (!this.config.censusUrl && !this.censusProviders.merkle && !this.censusProviders.csp) {
+      throw new Error(
+        "Census URL is required for voting. Provide censusUrl in the SDK constructor config, or use custom census providers."
+      );
+    }
     return this.voteOrchestrator.submitVote(config);
   }
   /**
    * 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);
@@ -1865,11 +2804,13 @@ class DavinciSDK {
   }
   /**
    * 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...");
@@ -1880,108 +2821,415 @@ class DavinciSDK {
    */
   async hasAddressVoted(processId, address) {
     if (!this.initialized) {
-      throw new Error("SDK must be initialized before checking vote status. Call sdk.init() first.");
+      throw new Error(
+        "SDK must be initialized before checking vote status. Call sdk.init() first."
+      );
     }
     return this.voteOrchestrator.hasAddressVoted(processId, address);
   }
+  /**
+   * 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, voteId, options) {
+    if (!this.initialized) {
+      throw new Error(
+        "SDK must be initialized before watching vote status. Call sdk.init() first."
+      );
+    }
+    return this.voteOrchestrator.watchVoteStatus(processId, voteId, options);
+  }
   /**
    * Wait for a vote to reach a specific status.
-   * Useful for waiting for vote confirmation and processing.
-   * 
+   * 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],
-   *   voterKey: "0x..."
+   *   choices: [1]
    * });
-   * 
+   *
    * // Wait for the vote to be fully processed
    * const finalStatus = await sdk.waitForVoteStatus(
    *   voteResult.processId,
    *   voteResult.voteId,
-   *   "settled", // Wait until vote is settled
+   *   VoteStatus.Settled, // Wait until vote is settled
    *   300000,    // 5 minute timeout
    *   5000       // Check every 5 seconds
    * );
-   * 
+   *
    * console.log("Vote final status:", finalStatus.status);
    * ```
    */
   async waitForVoteStatus(processId, voteId, targetStatus = VoteStatus.Settled, timeoutMs = 3e5, pollIntervalMs = 5e3) {
     if (!this.initialized) {
-      throw new Error("SDK must be initialized before waiting for vote status. Call sdk.init() first.");
+      throw new Error(
+        "SDK must be initialized before waiting for vote status. Call sdk.init() first."
+      );
     }
-    return this.voteOrchestrator.waitForVoteStatus(processId, voteId, targetStatus, timeoutMs, pollIntervalMs);
+    return this.voteOrchestrator.waitForVoteStatus(
+      processId,
+      voteId,
+      targetStatus,
+      timeoutMs,
+      pollIntervalMs
+    );
   }
   /**
-   * 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
+   * 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;
+   *   }
+   * }
+   * ```
    */
-  resolveContractAddress(contractName) {
-    if (this.config.useSequencerAddresses) {
-      return this.getDefaultContractAddress(contractName);
+  endProcessStream(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before ending processes. Call sdk.init() first.");
     }
-    const customAddress = this.config.contractAddresses[contractName];
-    if (customAddress) {
-      return customAddress;
+    this.ensureProvider();
+    return this.processOrchestrator.endProcessStream(processId);
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async endProcess(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before ending processes. Call sdk.init() first.");
     }
-    return this.getDefaultContractAddress(contractName);
+    this.ensureProvider();
+    return this.processOrchestrator.endProcess(processId);
   }
   /**
-   * Get default contract address from deployed addresses
+   * 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;
+   *   }
+   * }
+   * ```
    */
-  getDefaultContractAddress(contractName) {
-    const chain = this.config.chain;
-    switch (contractName) {
-      case "processRegistry":
-        return deployedAddresses.processRegistry[chain];
-      case "organizationRegistry":
-        return deployedAddresses.organizationRegistry[chain];
-      case "stateTransitionVerifier":
-        return deployedAddresses.stateTransitionVerifierGroth16[chain];
-      case "resultsVerifier":
-        return deployedAddresses.resultsVerifierGroth16[chain];
-      case "sequencerRegistry":
-        return deployedAddresses.sequencerRegistry[chain];
-      default:
-        throw new Error(`Unknown contract: ${contractName}`);
+  pauseProcessStream(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before pausing processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.pauseProcessStream(processId);
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async pauseProcess(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before pausing processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.pauseProcess(processId);
+  }
+  /**
+   * 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) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before canceling processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.cancelProcessStream(processId);
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async cancelProcess(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before canceling processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.cancelProcess(processId);
+  }
+  /**
+   * 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) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before resuming processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.resumeProcessStream(processId);
+  }
+  /**
+   * 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");
+   * ```
+   */
+  async resumeProcess(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before resuming processes. Call sdk.init() first.");
+    }
+    this.ensureProvider();
+    return this.processOrchestrator.resumeProcess(processId);
+  }
+  /**
+   * 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)
+   */
+  resolveContractAddress(contractName) {
+    const customAddress = this.config.customAddresses[contractName];
+    if (customAddress) {
+      return customAddress;
     }
+    if (!this.config.customAddresses[contractName]) {
+      throw new Error(
+        `Contract address for '${contractName}' not found. Make sure SDK is initialized with sdk.init() or provide custom addresses in config.`
+      );
+    }
+    return this.config.customAddresses[contractName];
   }
   /**
-   * Update contract addresses from sequencer info if useSequencerAddresses is enabled
-   * Sequencer addresses have priority over user-provided addresses
+   * Fetch contract addresses from sequencer info
+   * This is called during init() if custom addresses are not provided
    */
-  async updateContractAddressesFromSequencer() {
+  async fetchContractAddressesFromSequencer() {
     try {
       const info = await this.apiService.sequencer.getInfo();
       const contracts = info.contracts;
       if (contracts.process) {
+        this.config.customAddresses.processRegistry = contracts.process;
         this._processRegistry = new ProcessRegistryService(contracts.process, this.config.signer);
-        this.config.contractAddresses.processRegistry = contracts.process;
       }
       if (contracts.organization) {
-        this._organizationRegistry = new OrganizationRegistryService(contracts.organization, this.config.signer);
-        this.config.contractAddresses.organizationRegistry = contracts.organization;
+        this.config.customAddresses.organizationRegistry = contracts.organization;
+        this._organizationRegistry = new OrganizationRegistryService(
+          contracts.organization,
+          this.config.signer
+        );
       }
       if (contracts.stateTransitionVerifier) {
-        this.config.contractAddresses.stateTransitionVerifier = contracts.stateTransitionVerifier;
+        this.config.customAddresses.stateTransitionVerifier = contracts.stateTransitionVerifier;
       }
       if (contracts.resultsVerifier) {
-        this.config.contractAddresses.resultsVerifier = contracts.resultsVerifier;
+        this.config.customAddresses.resultsVerifier = contracts.resultsVerifier;
       }
     } catch (error) {
-      console.warn("Failed to fetch contract addresses from sequencer, using defaults:", error);
+      throw new Error(
+        `Failed to fetch contract addresses from sequencer: ${error instanceof Error ? error.message : String(error)}. You can provide custom addresses in the SDK config to avoid this error.`
+      );
     }
   }
   /**
@@ -1996,13 +3244,28 @@ class DavinciSDK {
   isInitialized() {
     return this.initialized;
   }
+  /**
+   * Ensures that the signer has a provider for blockchain operations.
+   * @throws Error if the signer does not have a provider
+   * @private
+   */
+  ensureProvider() {
+    if (!this.config.signer.provider) {
+      throw new Error(
+        "Provider required for blockchain operations (process/organization management). The signer must be connected to a provider. Use wallet.connect(provider) or a browser signer like MetaMask. Note: Voting operations do not require a provider."
+      );
+    }
+  }
 }
 
 exports.BaseService = BaseService;
+exports.Census = Census;
+exports.CensusOrchestrator = CensusOrchestrator;
 exports.CensusOrigin = CensusOrigin;
+exports.CensusType = CensusType;
 exports.CircomProof = CircomProof;
 exports.ContractServiceError = ContractServiceError;
-exports.DEFAULT_ENVIRONMENT_URLS = DEFAULT_ENVIRONMENT_URLS;
+exports.CspCensus = CspCensus;
 exports.DavinciCrypto = DavinciCrypto;
 exports.DavinciSDK = DavinciSDK;
 exports.ElectionMetadataTemplate = ElectionMetadataTemplate;
@@ -2012,6 +3275,7 @@ exports.OrganizationCreateError = OrganizationCreateError;
 exports.OrganizationDeleteError = OrganizationDeleteError;
 exports.OrganizationRegistryService = OrganizationRegistryService;
 exports.OrganizationUpdateError = OrganizationUpdateError;
+exports.PlainCensus = PlainCensus;
 exports.ProcessCensusError = ProcessCensusError;
 exports.ProcessCreateError = ProcessCreateError;
 exports.ProcessDurationError = ProcessDurationError;
@@ -2021,6 +3285,7 @@ exports.ProcessResultError = ProcessResultError;
 exports.ProcessStateTransitionError = ProcessStateTransitionError;
 exports.ProcessStatus = ProcessStatus;
 exports.ProcessStatusError = ProcessStatusError;
+exports.PublishedCensus = PublishedCensus;
 exports.SmartContractService = SmartContractService;
 exports.TxStatus = TxStatus;
 exports.VocdoniApiService = VocdoniApiService;
@@ -2028,18 +3293,13 @@ exports.VocdoniCensusService = VocdoniCensusService;
 exports.VocdoniSequencerService = VocdoniSequencerService;
 exports.VoteOrchestrationService = VoteOrchestrationService;
 exports.VoteStatus = VoteStatus;
+exports.WeightedCensus = WeightedCensus;
 exports.assertCSPCensusProof = assertCSPCensusProof;
 exports.assertMerkleCensusProof = assertMerkleCensusProof;
 exports.createProcessSignatureMessage = createProcessSignatureMessage;
-exports.deployedAddresses = deployedAddresses;
 exports.getElectionMetadataTemplate = getElectionMetadataTemplate;
-exports.getEnvironmentChain = getEnvironmentChain;
-exports.getEnvironmentConfig = getEnvironmentConfig;
-exports.getEnvironmentUrls = getEnvironmentUrls;
 exports.isCSPCensusProof = isCSPCensusProof;
 exports.isMerkleCensusProof = isMerkleCensusProof;
-exports.resolveConfiguration = resolveConfiguration;
-exports.resolveUrls = resolveUrls;
 exports.signProcessCreation = signProcessCreation;
 exports.validateProcessId = validateProcessId;
 //# sourceMappingURL=index.js.map