@vocdoni/davinci-sdk 0.0.2 → 0.0.4

package/dist/index.js

@@ -89,12 +89,12 @@ class VocdoniCensusService extends BaseService {
     super(baseURL);
   }
   /**
-   * Constructs the URI for accessing a census by its root
-   * @param censusRoot - The census root (hex-prefixed)
+   * Constructs the URI for accessing a census
+   * @param relativePath - The relative path
    * @returns The constructed URI for the census
    */
-  getCensusUri(censusRoot) {
-    return `${this.axios.defaults.baseURL}/censuses/${censusRoot}`;
+  getCensusUri(relativePath) {
+    return `${this.axios.defaults.baseURL}${relativePath}`;
   }
   createCensus() {
     return this.request({
@@ -163,10 +163,13 @@ class VocdoniCensusService extends BaseService {
     return this.request({
       method: "POST",
       url: `/censuses/${censusId}/publish`
-    }).then((response) => ({
-      ...response,
-      uri: this.getCensusUri(response.root)
-    }));
+    }).then((apiResponse) => {
+      const { censusUri, ...responseWithoutCensusUri } = apiResponse;
+      return {
+        ...responseWithoutCensusUri,
+        uri: this.getCensusUri(censusUri)
+      };
+    });
   }
   // BigQuery endpoints
   getSnapshots(params) {
@@ -196,13 +199,13 @@ var CensusOrigin = /* @__PURE__ */ ((CensusOrigin2) => {
   return CensusOrigin2;
 })(CensusOrigin || {});
 function isBaseCensusProof(proof) {
-  return !!proof && typeof proof.root === "string" && typeof proof.address === "string" && typeof proof.weight === "string" && typeof proof.censusOrigin === "number" && Object.values(CensusOrigin).includes(proof.censusOrigin);
+  return !!proof && typeof proof.root === "string" && typeof proof.address === "string" && typeof proof.censusOrigin === "number" && Object.values(CensusOrigin).includes(proof.censusOrigin);
 }
 function isMerkleCensusProof(proof) {
-  return isBaseCensusProof(proof) && proof.censusOrigin === 1 /* CensusOriginMerkleTree */ && typeof proof.value === "string" && typeof proof.siblings === "string";
+  return isBaseCensusProof(proof) && proof.censusOrigin === 1 /* CensusOriginMerkleTree */ && typeof proof.weight === "string" && typeof proof.value === "string" && typeof proof.siblings === "string";
 }
 function isCSPCensusProof(proof) {
-  return isBaseCensusProof(proof) && proof.censusOrigin === 2 /* CensusOriginCSP */ && typeof proof.processId === "string" && typeof proof.publicKey === "string" && typeof proof.signature === "string";
+  return isBaseCensusProof(proof) && proof.censusOrigin === 2 /* CensusOriginCSP */ && typeof proof.weight === "string" && typeof proof.processId === "string" && typeof proof.publicKey === "string" && typeof proof.signature === "string";
 }
 function assertMerkleCensusProof(proof) {
   if (!isMerkleCensusProof(proof)) {
@@ -215,6 +218,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}`;
@@ -287,6 +565,12 @@ class VocdoniSequencerService extends BaseService {
       throw error;
     }
   }
+  isAddressAbleToVote(processId, address) {
+    return this.request({
+      method: "GET",
+      url: `/processes/${processId}/participants/${address}`
+    });
+  }
   getInfo() {
     return this.request({
       method: "GET",
@@ -305,11 +589,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,101 +633,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: "0x50CA6A350f3A9C7B8a82eE7a4D5F0f21C54D68e3",
-	uzh: "0x69B16f67Bd2fB18bD720379E9C1Ef5EaD3872d67",
-	mainnet: "0x0",
-	celo: "0xDda6c75d32c375946C8ae9be41B2F3539dB1118A"
-};
-var organizationRegistry = {
-	sepolia: "0xF30678f579Fd89b86295503dC179d5d3aed47a98",
-	uzh: "0xf7BCE4546805547bE526Ca864d6722Ed193E51Aa",
-	mainnet: "0x0",
-	celo: "0xE17D701EA8f34022F97fC2Ec68c73D42bF99D0BD"
-};
-var stateTransitionVerifierGroth16 = {
-	sepolia: "0x96EcBbD6aB5fDC063E0fC426F2700290DeeAFE4E",
-	uzh: "0x5e4673CD378F05cc3Ae25804539c91E711548741",
-	mainnet: "0x0",
-	celo: "0x2DaF913D423128258b2F378E320F9D9D3Be5eCf5"
-};
-var resultsVerifierGroth16 = {
-	sepolia: "0x3ab37C40f7d0649f7a15BA3230f14AB29B51eDCC",
-	uzh: "0x00c7F87731346F592197E49A90Ad6EC236Ad9985",
-	mainnet: "0x0",
-	celo: "0x808276962217AD1ED3af7D51bFc791903CAd9389"
-};
-var sequencerRegistry = {
-	sepolia: "0x0",
-	uzh: "0x0",
-	mainnet: "0x0",
-	celo: "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";
@@ -458,19 +651,19 @@ class SmartContractService {
    * Sends a transaction and yields status events during its lifecycle.
    * This method handles the complete transaction flow from submission to completion,
    * including error handling and status updates.
-   * 
+   *
    * @template T - The type of the successful response data
    * @param txPromise - Promise resolving to the transaction response
    * @param responseHandler - Function to process the successful transaction result
    * @returns AsyncGenerator yielding transaction status events
-   * 
+   *
    * @example
    * ```typescript
    * const txStream = await this.sendTx(
    *   contract.someMethod(),
    *   async () => await contract.getUpdatedValue()
    * );
-   * 
+   *
    * for await (const event of txStream) {
    *   switch (event.status) {
    *     case TxStatus.Pending:
@@ -507,12 +700,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 {
@@ -542,11 +735,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) => {
@@ -569,12 +762,12 @@ class SmartContractService {
    * 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(
@@ -600,13 +793,14 @@ class SmartContractService {
       };
       if ("send" in provider && typeof provider.send === "function") {
         try {
-          await provider.send("eth_newFilter", [testFilter]);
+          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 support eth_newFilter, falling back to polling for events. This may result in delayed event notifications."
+              "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;
@@ -631,18 +825,23 @@ class SmartContractService {
     }
   }
   /**
-   * Checks if an error indicates that the RPC method is unsupported (eth_newFilter).
-   * 
+   * 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 method
+   * @returns true if the error indicates unsupported or broken filter functionality
    */
   isUnsupportedMethodError(error) {
-    return error?.code === -32601 || error?.error?.code === -32601 || error?.data?.code === -32601 || typeof error?.message === "string" && error.message.includes("unsupported method");
+    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
@@ -694,7 +893,7 @@ class SmartContractService {
   }
   /**
    * Sets the polling interval for event listeners using the fallback mechanism.
-   * 
+   *
    * @param intervalMs - Polling interval in milliseconds
    */
   setEventPollingInterval(intervalMs) {
@@ -705,7 +904,7 @@ class SmartContractService {
 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
    */
@@ -795,7 +994,6 @@ class ProcessRegistryService extends SmartContractService {
   newProcess(status, startTime, duration, ballotMode, census, metadata, encryptionKey, initStateRoot) {
     const contractCensus = {
       censusOrigin: BigInt(census.censusOrigin),
-      maxVotes: BigInt(census.maxVotes),
       censusRoot: census.censusRoot,
       censusURI: census.censusURI
     };
@@ -826,7 +1024,6 @@ class ProcessRegistryService extends SmartContractService {
   setProcessCensus(processID, census) {
     const contractCensus = {
       censusOrigin: BigInt(census.censusOrigin),
-      maxVotes: BigInt(census.maxVotes),
       censusRoot: census.censusRoot,
       censusURI: census.censusURI
     };
@@ -858,7 +1055,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
@@ -866,11 +1063,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 })
@@ -932,6 +1125,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
@@ -971,7 +1192,6 @@ class ProcessOrchestrationService {
     const census = {
       type: Number(rawProcess.census.censusOrigin),
       root: rawProcess.census.censusRoot,
-      size: Number(rawProcess.census.maxVotes),
       uri: rawProcess.census.censusURI || ""
     };
     const ballot = {
@@ -986,11 +1206,11 @@ class ProcessOrchestrationService {
     };
     return {
       processId,
-      title,
+      title: title || "",
       description,
       census,
       ballot,
-      questions,
+      questions: questions || [],
       status: Number(rawProcess.status),
       creator: rawProcess.organizationId,
       startDate: new Date(startTime * 1e3),
@@ -1007,10 +1227,10 @@ class ProcessOrchestrationService {
   /**
    * 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({
@@ -1021,7 +1241,7 @@ class ProcessOrchestrationService {
    *   timing: { ... },
    *   questions: [ ... ]
    * });
-   * 
+   *
    * for await (const event of stream) {
    *   switch (event.status) {
    *     case "pending":
@@ -1083,16 +1303,16 @@ class ProcessOrchestrationService {
   /**
    * 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
    */
@@ -1116,24 +1336,32 @@ class ProcessOrchestrationService {
     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);
-    const metadataUri = this.apiService.sequencer.getMetadataUrl(metadataHash);
+    let metadataUri;
+    if ("metadataUri" in config) {
+      metadataUri = config.metadataUri;
+    } else {
+      const metadata = this.createMetadata(config);
+      const metadataHash = await this.apiService.sequencer.pushMetadata(metadata);
+      metadataUri = this.apiService.sequencer.getMetadataUrl(metadataHash);
+    }
     const signature = await signProcessCreation(processId, this.signer);
     const sequencerResult = await this.apiService.sequencer.createProcess({
       processId,
-      censusRoot,
+      census: {
+        censusOrigin: censusConfig.type,
+        censusRoot,
+        censusURI: censusConfig.uri
+      },
       ballotMode,
-      signature,
-      censusOrigin: config.census.type
+      signature
     });
     const census = {
-      censusOrigin: config.census.type,
-      maxVotes: config.census.size.toString(),
+      censusOrigin: censusConfig.type,
       censusRoot,
-      censusURI: config.census.uri
+      censusURI: censusConfig.uri
     };
     return {
       processId,
@@ -1200,15 +1428,13 @@ class ProcessOrchestrationService {
     throw new Error("Invalid date format. Use Date object, ISO string, or Unix timestamp.");
   }
   /**
-   * Creates metadata from the simplified configuration
+   * Creates metadata from the configuration with metadata fields
+   * This method should only be called with ProcessConfigWithMetadata
    */
   createMetadata(config) {
     const metadata = getElectionMetadataTemplate();
     metadata.title.default = config.title;
     metadata.description.default = config.description || "";
-    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 || "" },
@@ -1224,14 +1450,14 @@ class ProcessOrchestrationService {
   /**
    * 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":
@@ -1273,12 +1499,12 @@ class ProcessOrchestrationService {
   /**
    * 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...");
@@ -1300,14 +1526,14 @@ class ProcessOrchestrationService {
   /**
    * 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":
@@ -1349,12 +1575,12 @@ class ProcessOrchestrationService {
   /**
    * 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...");
@@ -1376,14 +1602,14 @@ class ProcessOrchestrationService {
   /**
    * 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":
@@ -1425,12 +1651,12 @@ class ProcessOrchestrationService {
   /**
    * 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...");
@@ -1453,14 +1679,14 @@ class ProcessOrchestrationService {
    * 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":
@@ -1503,12 +1729,12 @@ class ProcessOrchestrationService {
    * 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...");
@@ -1596,11 +1822,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
@@ -1635,11 +1857,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
@@ -1648,7 +1872,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
    */
@@ -1675,16 +1899,19 @@ class VoteOrchestrationService {
     );
     const { proof } = await this.generateZkProof(circomInputs);
     const signature = await this.signVote(voteId);
-    await this.submitVoteRequest({
+    const voteRequest = {
       processId: config.processId,
-      censusProof,
       ballot: cryptoOutput.ballot,
       ballotProof: proof,
       ballotInputsHash: cryptoOutput.ballotInputsHash,
       address: voterAddress,
       signature,
       voteId
-    });
+    };
+    if (process.census.censusOrigin === CensusOrigin.CensusOriginCSP) {
+      voteRequest.censusProof = censusProof;
+    }
+    await this.submitVoteRequest(voteRequest);
     const status = await this.apiService.sequencer.getVoteStatus(config.processId, voteId);
     return {
       voteId,
@@ -1696,7 +1923,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
@@ -1711,7 +1938,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
@@ -1722,19 +1949,19 @@ class VoteOrchestrationService {
   /**
    * 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...");
@@ -1771,7 +1998,7 @@ class VoteOrchestrationService {
   /**
    * 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")
@@ -1874,12 +2101,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 };
   }
@@ -1917,10 +2152,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) {
@@ -2123,14 +2355,15 @@ class DavinciCrypto {
    * @param privKey - The private key in hex format
    * @param processId - The process ID in hex format
    * @param address - The address in hex format
+   * @param weight - The vote weight as a decimal string
    * @returns The CSP proof as a parsed JSON object
    * @throws if called before `await init()`, or if Go returns an error
    */
-  async cspSign(censusOrigin, privKey, processId, address) {
+  async cspSign(censusOrigin, privKey, processId, address, weight) {
     if (!this.initialized) {
       throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
     }
-    const raw = globalThis.DavinciCrypto.cspSign(censusOrigin, privKey, processId, address);
+    const raw = globalThis.DavinciCrypto.cspSign(censusOrigin, privKey, processId, address, weight);
     if (raw.error) {
       throw new Error(`Go/WASM cspSign error: ${raw.error}`);
     }
@@ -2144,13 +2377,14 @@ class DavinciCrypto {
    * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
    * @param root - The census root
    * @param address - The address
+   * @param weight - The vote weight as a decimal string
    * @param processId - The process ID
    * @param publicKey - The public key
    * @param signature - The signature
    * @returns The verification result
    * @throws if called before `await init()`, or if Go returns an error
    */
-  async cspVerify(censusOrigin, root, address, processId, publicKey, signature) {
+  async cspVerify(censusOrigin, root, address, weight, processId, publicKey, signature) {
     if (!this.initialized) {
       throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
     }
@@ -2158,6 +2392,7 @@ class DavinciCrypto {
       censusOrigin,
       root,
       address,
+      weight,
       processId,
       publicKey,
       signature
@@ -2196,25 +2431,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 || {};
   }
@@ -2224,9 +2457,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;
   }
   /**
@@ -2238,28 +2472,34 @@ class DavinciSDK {
   /**
    * 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.
    * 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;
   }
@@ -2280,7 +2520,7 @@ class DavinciSDK {
   /**
    * 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() {
@@ -2305,7 +2545,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;
@@ -2314,24 +2558,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);
@@ -2339,7 +2583,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);
    * ```
@@ -2355,13 +2599,13 @@ class DavinciSDK {
    * 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({
@@ -2397,7 +2641,7 @@ class DavinciSDK {
    *     }
    *   ]
    * });
-   * 
+   *
    * // Monitor transaction progress
    * for await (const event of stream) {
    *   switch (event.status) {
@@ -2432,22 +2676,22 @@ class DavinciSDK {
   /**
    * 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)
@@ -2484,7 +2728,7 @@ class DavinciSDK {
    *     }
    *   ]
    * });
-   * 
+   *
    * // Option 2: Using start and end dates
    * const result2 = await sdk.createProcess({
    *   title: "Weekend Vote",
@@ -2505,18 +2749,20 @@ class DavinciSDK {
   /**
    * 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
@@ -2525,14 +2771,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
@@ -2544,17 +2790,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);
@@ -2570,13 +2821,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...");
@@ -2587,22 +2838,48 @@ 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);
   }
+  /**
+   * Check if an address is able to vote in a process and get participant information.
+   *
+   * Does NOT require a provider - uses API calls only.
+   *
+   * @param processId - The process ID
+   * @param address - The voter's address
+   * @returns Promise resolving to participant information (key and weight)
+   *
+   * @example
+   * ```typescript
+   * const participantInfo = await sdk.isAddressAbleToVote(processId, "0x1234567890abcdef...");
+   * console.log("Address:", participantInfo.key);
+   * console.log("Weight:", participantInfo.weight);
+   * ```
+   */
+  async isAddressAbleToVote(processId, address) {
+    if (!this.initialized) {
+      throw new Error(
+        "SDK must be initialized before checking participant info. Call sdk.init() first."
+      );
+    }
+    return this.apiService.sequencer.isAddressAbleToVote(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 
+   * 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
@@ -2610,11 +2887,11 @@ class DavinciSDK {
    *   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...");
@@ -2634,7 +2911,9 @@ class DavinciSDK {
    */
   watchVoteStatus(processId, voteId, options) {
     if (!this.initialized) {
-      throw new Error("SDK must be initialized before watching vote status. Call sdk.init() first.");
+      throw new Error(
+        "SDK must be initialized before watching vote status. Call sdk.init() first."
+      );
     }
     return this.voteOrchestrator.watchVoteStatus(processId, voteId, options);
   }
@@ -2642,16 +2921,16 @@ class DavinciSDK {
    * 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
@@ -2659,7 +2938,7 @@ class DavinciSDK {
    *   processId: "0x1234567890abcdef...",
    *   choices: [1]
    * });
-   * 
+   *
    * // Wait for the vote to be fully processed
    * const finalStatus = await sdk.waitForVoteStatus(
    *   voteResult.processId,
@@ -2668,31 +2947,39 @@ class DavinciSDK {
    *   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
+    );
   }
   /**
-   * 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 
+   * 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:
@@ -2721,15 +3008,15 @@ class DavinciSDK {
   /**
    * 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...");
@@ -2744,20 +3031,20 @@ class DavinciSDK {
     return this.processOrchestrator.endProcess(processId);
   }
   /**
-   * 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 
+   * 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:
@@ -2786,15 +3073,15 @@ class DavinciSDK {
   /**
    * 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...");
@@ -2809,20 +3096,20 @@ class DavinciSDK {
     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 
+   * 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:
@@ -2851,15 +3138,15 @@ class DavinciSDK {
   /**
    * 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...");
@@ -2874,19 +3161,19 @@ class DavinciSDK {
     return this.processOrchestrator.cancelProcess(processId);
   }
   /**
-   * Resumes a voting process by setting its status to READY and returns an async generator 
+   * 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:
@@ -2916,15 +3203,15 @@ class DavinciSDK {
    * 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...");
@@ -2940,64 +3227,50 @@ class DavinciSDK {
   }
   /**
    * 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
+   * 1. Custom addresses from user config (if provided)
+   * 2. Addresses from sequencer (fetched during init if no custom addresses provided)
    */
   resolveContractAddress(contractName) {
-    if (this.config.useSequencerAddresses) {
-      return this.getDefaultContractAddress(contractName);
-    }
-    const customAddress = this.config.contractAddresses[contractName];
+    const customAddress = this.config.customAddresses[contractName];
     if (customAddress) {
       return customAddress;
     }
-    return this.getDefaultContractAddress(contractName);
-  }
-  /**
-   * Get default contract address from deployed addresses
-   */
-  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}`);
+    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.`
+      );
     }
   }
   /**
@@ -3027,10 +3300,13 @@ class DavinciSDK {
 }
 
 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;
@@ -3040,6 +3316,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;
@@ -3049,6 +3326,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;
@@ -3056,18 +3334,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