@vocdoni/davinci-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2045 @@
+'use strict';
+
+var axios = require('axios');
+var davinciContracts = require('@vocdoni/davinci-contracts');
+var snarkjs = require('snarkjs');
+var ethers = require('ethers');
+
+var ElectionResultsTypeNames = /* @__PURE__ */ ((ElectionResultsTypeNames2) => {
+  ElectionResultsTypeNames2["SINGLE_CHOICE_MULTIQUESTION"] = "single-choice-multiquestion";
+  ElectionResultsTypeNames2["MULTIPLE_CHOICE"] = "multiple-choice";
+  ElectionResultsTypeNames2["BUDGET"] = "budget-based";
+  ElectionResultsTypeNames2["APPROVAL"] = "approval";
+  ElectionResultsTypeNames2["QUADRATIC"] = "quadratic";
+  return ElectionResultsTypeNames2;
+})(ElectionResultsTypeNames || {});
+const ElectionMetadataTemplate = {
+  version: "1.2",
+  title: {
+    default: ""
+  },
+  description: {
+    default: ""
+  },
+  media: {
+    header: "",
+    logo: ""
+  },
+  meta: {},
+  questions: [
+    {
+      title: {
+        default: ""
+      },
+      description: {
+        default: ""
+      },
+      meta: {},
+      choices: [
+        {
+          title: {
+            default: "Yes"
+          },
+          value: 0,
+          meta: {}
+        },
+        {
+          title: {
+            default: "No"
+          },
+          value: 1,
+          meta: {}
+        }
+      ]
+    }
+  ],
+  type: {
+    name: "single-choice-multiquestion" /* SINGLE_CHOICE_MULTIQUESTION */,
+    properties: {}
+  }
+};
+const getElectionMetadataTemplate = () => {
+  return JSON.parse(JSON.stringify(ElectionMetadataTemplate));
+};
+
+class BaseService {
+  constructor(baseURL, config) {
+    this.axios = axios.create({ baseURL, ...config });
+  }
+  async request(config) {
+    try {
+      const response = await this.axios.request(config);
+      return response.data;
+    } catch (err) {
+      const error = err;
+      const message = error.response?.data?.error || error.message;
+      const code = error.response?.data?.code || error.code || error.response?.status || 500;
+      const e = new Error(message);
+      e.code = code;
+      throw e;
+    }
+  }
+}
+
+function isUUId(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str);
+}
+class VocdoniCensusService extends BaseService {
+  constructor(baseURL) {
+    super(baseURL);
+  }
+  /**
+   * Constructs the URI for accessing a census by its root
+   * @param censusRoot - The census root (hex-prefixed)
+   * @returns The constructed URI for the census
+   */
+  getCensusUri(censusRoot) {
+    return `${this.axios.defaults.baseURL}/censuses/${censusRoot}`;
+  }
+  createCensus() {
+    return this.request({
+      method: "POST",
+      url: "/censuses"
+    }).then((res) => res.census);
+  }
+  async addParticipants(censusId, participants) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    await this.request({
+      method: "POST",
+      url: `/censuses/${censusId}/participants`,
+      data: { participants }
+    });
+  }
+  getParticipants(censusId) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    return this.request({
+      method: "GET",
+      url: `/censuses/${censusId}/participants`
+    }).then((res) => res.participants);
+  }
+  getCensusRoot(censusId) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    return this.request({
+      method: "GET",
+      url: `/censuses/${censusId}/root`
+    }).then((res) => res.root);
+  }
+  getCensusSizeById(censusId) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    return this.request({
+      method: "GET",
+      url: `/censuses/${censusId}/size`
+    }).then((res) => res.size);
+  }
+  getCensusSizeByRoot(censusRoot) {
+    return this.request({
+      method: "GET",
+      url: `/censuses/${censusRoot}/size`
+    }).then((res) => res.size);
+  }
+  getCensusSize(censusIdOrRoot) {
+    if (isUUId(censusIdOrRoot)) {
+      return this.getCensusSizeById(censusIdOrRoot);
+    } else {
+      return this.getCensusSizeByRoot(censusIdOrRoot);
+    }
+  }
+  async deleteCensus(censusId) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    await this.request({
+      method: "DELETE",
+      url: `/censuses/${censusId}`
+    });
+  }
+  getCensusProof(censusRoot, key) {
+    return this.request({
+      method: "GET",
+      url: `/censuses/${censusRoot}/proof`,
+      params: { key }
+    });
+  }
+  publishCensus(censusId) {
+    if (!isUUId(censusId)) throw new Error("Invalid census ID format");
+    return this.request({
+      method: "POST",
+      url: `/censuses/${censusId}/publish`
+    }).then((response) => ({
+      ...response,
+      uri: this.getCensusUri(response.root)
+    }));
+  }
+  // BigQuery endpoints
+  getSnapshots(params) {
+    return this.request({
+      method: "GET",
+      url: "/snapshots",
+      params
+    });
+  }
+  getLatestSnapshot() {
+    return this.request({
+      method: "GET",
+      url: "/snapshots/latest"
+    });
+  }
+  getHealth() {
+    return this.request({
+      method: "GET",
+      url: "/health"
+    });
+  }
+}
+
+var CensusOrigin = /* @__PURE__ */ ((CensusOrigin2) => {
+  CensusOrigin2[CensusOrigin2["CensusOriginMerkleTree"] = 1] = "CensusOriginMerkleTree";
+  CensusOrigin2[CensusOrigin2["CensusOriginCSP"] = 2] = "CensusOriginCSP";
+  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);
+}
+function isMerkleCensusProof(proof) {
+  return isBaseCensusProof(proof) && proof.censusOrigin === 1 /* CensusOriginMerkleTree */ && 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";
+}
+function assertMerkleCensusProof(proof) {
+  if (!isMerkleCensusProof(proof)) {
+    throw new Error("Invalid Merkle census proof payload");
+  }
+}
+function assertCSPCensusProof(proof) {
+  if (!isCSPCensusProof(proof)) {
+    throw new Error("Invalid CSP census proof payload");
+  }
+}
+
+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}`;
+}
+async function signProcessCreation(processId, signer) {
+  const message = createProcessSignatureMessage(processId);
+  return await signer.signMessage(message);
+}
+function validateProcessId(processId) {
+  const cleanId = processId.replace(/^0x/, "");
+  return /^[0-9a-fA-F]{64}$/.test(cleanId);
+}
+
+function isHexString(str) {
+  return /^0x[0-9a-f]{64}$/i.test(str);
+}
+class VocdoniSequencerService extends BaseService {
+  constructor(baseURL) {
+    super(baseURL);
+  }
+  async ping() {
+    await this.request({ method: "GET", url: "/ping" });
+  }
+  createProcess(body) {
+    if (!validateProcessId(body.processId)) {
+      throw new Error("Invalid processId format. Must be a 64-character hex string (32 bytes)");
+    }
+    return this.request({
+      method: "POST",
+      url: "/processes",
+      data: body
+    });
+  }
+  getProcess(processId) {
+    return this.request({
+      method: "GET",
+      url: `/processes/${processId}`
+    });
+  }
+  listProcesses() {
+    return this.request({
+      method: "GET",
+      url: "/processes"
+    }).then((res) => res.processes);
+  }
+  async submitVote(vote) {
+    await this.request({
+      method: "POST",
+      url: "/votes",
+      data: vote
+    });
+  }
+  getVoteStatus(processId, voteId) {
+    return this.request({
+      method: "GET",
+      url: `/votes/${processId}/voteId/${voteId}`
+    });
+  }
+  async hasAddressVoted(processId, address) {
+    try {
+      await this.request({
+        method: "GET",
+        url: `/votes/${processId}/address/${address}`
+      });
+      return true;
+    } catch (error) {
+      if (error?.code === 40001) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  getInfo() {
+    return this.request({
+      method: "GET",
+      url: "/info"
+    });
+  }
+  pushMetadata(metadata) {
+    return this.request({
+      method: "POST",
+      url: "/metadata",
+      data: metadata
+    }).then((res) => res.hash);
+  }
+  async getMetadata(hashOrUrl) {
+    if (hashOrUrl.startsWith("http://") || hashOrUrl.startsWith("https://")) {
+      try {
+        const response = await fetch(hashOrUrl);
+        if (!response.ok) {
+          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"}`);
+      }
+    }
+    if (!isHexString(hashOrUrl)) {
+      throw new Error("Invalid metadata hash format");
+    }
+    return this.request({
+      method: "GET",
+      url: `/metadata/${hashOrUrl}`
+    });
+  }
+  getMetadataUrl(hash) {
+    if (!isHexString(hash)) throw new Error("Invalid metadata hash format");
+    return `${this.axios.defaults.baseURL}/metadata/${hash}`;
+  }
+  getStats() {
+    return this.request({
+      method: "GET",
+      url: "/sequencer/stats"
+    });
+  }
+  getWorkers() {
+    return this.request({
+      method: "GET",
+      url: "/sequencer/workers"
+    });
+  }
+}
+
+class VocdoniApiService {
+  constructor(config) {
+    this.sequencer = new VocdoniSequencerService(config.sequencerURL);
+    this.census = new VocdoniCensusService(config.censusURL);
+  }
+}
+
+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";
+  TxStatus2["Reverted"] = "reverted";
+  TxStatus2["Failed"] = "failed";
+  return TxStatus2;
+})(TxStatus || {});
+class SmartContractService {
+  /**
+   * Sends a transaction and yields status events during its lifecycle.
+   * This method handles the complete transaction flow from submission to completion,
+   * including error handling and status updates.
+   * 
+   * @template T - The type of the successful response data
+   * @param txPromise - Promise resolving to the transaction response
+   * @param responseHandler - Function to process the successful transaction result
+   * @returns AsyncGenerator yielding transaction status events
+   * 
+   * @example
+   * ```typescript
+   * const txStream = await this.sendTx(
+   *   contract.someMethod(),
+   *   async () => await contract.getUpdatedValue()
+   * );
+   * 
+   * for await (const event of txStream) {
+   *   switch (event.status) {
+   *     case TxStatus.Pending:
+   *       console.log(`Transaction pending: ${event.hash}`);
+   *       break;
+   *     case TxStatus.Completed:
+   *       console.log(`Transaction completed:`, event.response);
+   *       break;
+   *   }
+   * }
+   * ```
+   */
+  async *sendTx(txPromise, responseHandler) {
+    try {
+      const tx = await txPromise;
+      yield { status: "pending" /* Pending */, hash: tx.hash };
+      const receipt = await tx.wait();
+      if (!receipt) {
+        yield { status: "reverted" /* Reverted */, reason: "Transaction was dropped or not mined." };
+      } else if (receipt.status === 0) {
+        yield { status: "reverted" /* Reverted */, reason: "Transaction reverted." };
+      } else {
+        const result = await responseHandler();
+        yield { status: "completed" /* Completed */, response: result };
+      }
+    } catch (err) {
+      yield {
+        status: "failed" /* Failed */,
+        error: err instanceof Error ? err : new Error("Unknown transaction error")
+      };
+    }
+  }
+  /**
+   * Executes a transaction stream and returns the result or throws an error.
+   * This is a convenience method that processes a transaction stream and either
+   * returns the successful result or throws an appropriate error.
+   * 
+   * @template T - The type of the successful response data
+   * @param stream - AsyncGenerator of transaction status events
+   * @returns Promise resolving to the successful response data
+   * @throws Error if the transaction fails or reverts
+   * 
+   * @example
+   * ```typescript
+   * try {
+   *   const result = await SmartContractService.executeTx(
+   *     contract.someMethod()
+   *   );
+   *   console.log('Transaction successful:', result);
+   * } catch (error) {
+   *   console.error('Transaction failed:', error);
+   * }
+   * ```
+   */
+  static async executeTx(stream) {
+    for await (const event of stream) {
+      switch (event.status) {
+        case "completed" /* Completed */:
+          return event.response;
+        case "failed" /* Failed */:
+          throw event.error;
+        case "reverted" /* Reverted */:
+          throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+      }
+    }
+    throw new Error("Transaction stream ended unexpectedly");
+  }
+  /**
+   * Normalizes event listener arguments between different ethers.js versions.
+   * This helper method ensures consistent event argument handling regardless of
+   * whether the event payload follows ethers v5 or v6 format.
+   * 
+   * @template Args - Tuple type representing the expected event arguments
+   * @param callback - The event callback function to normalize
+   * @returns Normalized event listener function
+   * 
+   * @example
+   * ```typescript
+   * contract.on('Transfer', this.normalizeListener((from: string, to: string, amount: BigInt) => {
+   *   console.log(`Transfer from ${from} to ${to}: ${amount}`);
+   * }));
+   * ```
+   */
+  normalizeListener(callback) {
+    return (...listenerArgs) => {
+      let args;
+      if (listenerArgs.length === 1 && listenerArgs[0]?.args) {
+        args = listenerArgs[0].args;
+      } else {
+        args = listenerArgs;
+      }
+      callback(...args);
+    };
+  }
+}
+
+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
+   */
+  constructor(message, operation) {
+    super(message);
+    this.operation = operation;
+    this.name = this.constructor.name;
+  }
+}
+class OrganizationCreateError extends ContractServiceError {
+}
+class OrganizationUpdateError extends ContractServiceError {
+}
+class OrganizationDeleteError extends ContractServiceError {
+}
+class OrganizationAdministratorError extends ContractServiceError {
+}
+class ProcessCreateError extends ContractServiceError {
+}
+class ProcessStatusError extends ContractServiceError {
+}
+class ProcessCensusError extends ContractServiceError {
+}
+class ProcessDurationError extends ContractServiceError {
+}
+class ProcessStateTransitionError extends ContractServiceError {
+}
+class ProcessResultError extends ContractServiceError {
+}
+
+var ProcessStatus = /* @__PURE__ */ ((ProcessStatus2) => {
+  ProcessStatus2[ProcessStatus2["READY"] = 0] = "READY";
+  ProcessStatus2[ProcessStatus2["ENDED"] = 1] = "ENDED";
+  ProcessStatus2[ProcessStatus2["CANCELED"] = 2] = "CANCELED";
+  ProcessStatus2[ProcessStatus2["PAUSED"] = 3] = "PAUSED";
+  ProcessStatus2[ProcessStatus2["RESULTS"] = 4] = "RESULTS";
+  return ProcessStatus2;
+})(ProcessStatus || {});
+class ProcessRegistryService extends SmartContractService {
+  constructor(contractAddress, runner) {
+    super();
+    this.contract = davinciContracts.ProcessRegistry__factory.connect(contractAddress, runner);
+  }
+  // ─── READS ─────────────────────────────────────────────────────────
+  async getProcess(processID) {
+    return this.contract.getProcess(processID);
+  }
+  async getProcessCount() {
+    const c = await this.contract.processCount();
+    return Number(c);
+  }
+  async getChainID() {
+    const chainId = await this.contract.chainID();
+    return chainId.toString();
+  }
+  async getNextProcessId(organizationId) {
+    return this.contract.getNextProcessId(organizationId);
+  }
+  async getProcessEndTime(processID) {
+    return this.contract.getProcessEndTime(processID);
+  }
+  async getRVerifierVKeyHash() {
+    return this.contract.getRVerifierVKeyHash();
+  }
+  async getSTVerifierVKeyHash() {
+    return this.contract.getSTVerifierVKeyHash();
+  }
+  async getMaxCensusOrigin() {
+    return this.contract.MAX_CENSUS_ORIGIN();
+  }
+  async getMaxStatus() {
+    return this.contract.MAX_STATUS();
+  }
+  async getProcessNonce(address) {
+    return this.contract.processNonce(address);
+  }
+  async getProcessDirect(processID) {
+    return this.contract.processes(processID);
+  }
+  async getRVerifier() {
+    return this.contract.rVerifier();
+  }
+  async getSTVerifier() {
+    return this.contract.stVerifier();
+  }
+  // ─── WRITES ────────────────────────────────────────────────────────
+  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
+    };
+    return this.sendTx(
+      this.contract.newProcess(
+        status,
+        startTime,
+        duration,
+        ballotMode,
+        contractCensus,
+        metadata,
+        encryptionKey,
+        initStateRoot
+      ).catch((e) => {
+        throw new ProcessCreateError(e.message, "create");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  setProcessStatus(processID, newStatus) {
+    return this.sendTx(
+      this.contract.setProcessStatus(processID, newStatus).catch((e) => {
+        throw new ProcessStatusError(e.message, "setStatus");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  setProcessCensus(processID, census) {
+    const contractCensus = {
+      censusOrigin: BigInt(census.censusOrigin),
+      maxVotes: BigInt(census.maxVotes),
+      censusRoot: census.censusRoot,
+      censusURI: census.censusURI
+    };
+    return this.sendTx(
+      this.contract.setProcessCensus(processID, contractCensus).catch((e) => {
+        throw new ProcessCensusError(e.message, "setCensus");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  setProcessDuration(processID, duration) {
+    return this.sendTx(
+      this.contract.setProcessDuration(processID, duration).catch((e) => {
+        throw new ProcessDurationError(e.message, "setDuration");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  /**
+   * Matches the on-chain `submitStateTransition(processId, proof, input)`
+   */
+  submitStateTransition(processID, proof, input) {
+    return this.sendTx(
+      this.contract.submitStateTransition(processID, proof, input).catch((e) => {
+        throw new ProcessStateTransitionError(e.message, "submitStateTransition");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  /**
+   * Sets the results for a voting process.
+   * 
+   * @param processID - The ID of the process to set results for
+   * @param proof - Zero-knowledge proof validating the results
+   * @param input - Input data for the proof verification
+   * @returns A transaction stream that resolves to success status
+   */
+  setProcessResults(processID, proof, input) {
+    return this.sendTx(
+      this.contract.setProcessResults(
+        processID,
+        proof,
+        input
+      ).catch((e) => {
+        throw new ProcessResultError(e.message, "setResults");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  // ─── EVENT LISTENERS ───────────────────────────────────────────────────────
+  onProcessCreated(cb) {
+    this.contract.on(
+      this.contract.filters.ProcessCreated(),
+      this.normalizeListener(cb)
+    );
+  }
+  onProcessStatusChanged(cb) {
+    this.contract.on(
+      this.contract.filters.ProcessStatusChanged(),
+      this.normalizeListener(cb)
+    );
+  }
+  onCensusUpdated(cb) {
+    this.contract.on(
+      this.contract.filters.CensusUpdated(),
+      this.normalizeListener(cb)
+    );
+  }
+  onProcessDurationChanged(cb) {
+    this.contract.on(
+      this.contract.filters.ProcessDurationChanged(),
+      this.normalizeListener(cb)
+    );
+  }
+  onStateRootUpdated(cb) {
+    this.contract.on(
+      this.contract.filters.ProcessStateRootUpdated(),
+      this.normalizeListener(cb)
+    );
+  }
+  onProcessResultsSet(cb) {
+    this.contract.on(
+      this.contract.filters.ProcessResultsSet(),
+      this.normalizeListener(cb)
+    );
+  }
+  removeAllListeners() {
+    this.contract.removeAllListeners();
+  }
+}
+
+class ProcessOrchestrationService {
+  constructor(processRegistry, apiService, organizationRegistry, getCrypto, signer) {
+    this.processRegistry = processRegistry;
+    this.apiService = apiService;
+    this.organizationRegistry = organizationRegistry;
+    this.getCrypto = getCrypto;
+    this.signer = signer;
+  }
+  /**
+   * Gets user-friendly process information by transforming raw contract data
+   * @param processId - The process ID to fetch
+   * @returns Promise resolving to the user-friendly process information
+   */
+  async getProcess(processId) {
+    const rawProcess = await this.processRegistry.getProcess(processId);
+    let metadata = null;
+    let title;
+    let description;
+    let questions = [];
+    try {
+      if (rawProcess.metadataURI) {
+        metadata = await this.apiService.sequencer.getMetadata(rawProcess.metadataURI);
+        title = metadata?.title?.default;
+        description = metadata?.description?.default;
+        if (metadata?.questions) {
+          questions = metadata.questions.map((q) => ({
+            title: q.title?.default,
+            description: q.description?.default,
+            choices: q.choices?.map((c) => ({
+              title: c.title?.default,
+              value: c.value
+            })) || []
+          }));
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to fetch metadata for process ${processId}:`, error);
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const startTime = Number(rawProcess.startTime);
+    const duration = Number(rawProcess.duration);
+    const endTime = startTime + duration;
+    const timeRemaining = now >= endTime ? 0 : now >= startTime ? endTime - now : startTime - now;
+    const census = {
+      type: Number(rawProcess.census.censusOrigin),
+      root: rawProcess.census.censusRoot,
+      size: Number(rawProcess.census.maxVotes),
+      uri: rawProcess.census.censusURI || ""
+    };
+    const ballot = {
+      numFields: Number(rawProcess.ballotMode.numFields),
+      maxValue: rawProcess.ballotMode.maxValue.toString(),
+      minValue: rawProcess.ballotMode.minValue.toString(),
+      uniqueValues: rawProcess.ballotMode.uniqueValues,
+      costFromWeight: rawProcess.ballotMode.costFromWeight,
+      costExponent: Number(rawProcess.ballotMode.costExponent),
+      maxValueSum: rawProcess.ballotMode.maxValueSum.toString(),
+      minValueSum: rawProcess.ballotMode.minValueSum.toString()
+    };
+    return {
+      processId,
+      title,
+      description,
+      census,
+      ballot,
+      questions,
+      status: Number(rawProcess.status),
+      creator: rawProcess.organizationId,
+      startDate: new Date(startTime * 1e3),
+      endDate: new Date(endTime * 1e3),
+      duration,
+      timeRemaining,
+      result: rawProcess.result,
+      voteCount: Number(rawProcess.voteCount),
+      voteOverwriteCount: Number(rawProcess.voteOverwriteCount),
+      metadataURI: rawProcess.metadataURI,
+      raw: rawProcess
+    };
+  }
+  /**
+   * Creates a complete voting process with minimal configuration
+   * This method handles all the complex orchestration internally
+   */
+  async createProcess(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 ballotMode = config.ballot;
+    const metadata = this.createMetadata(config);
+    const metadataHash = await this.apiService.sequencer.pushMetadata(metadata);
+    const metadataUri = this.apiService.sequencer.getMetadataUrl(metadataHash);
+    const signature = await signProcessCreation(processId, this.signer);
+    const sequencerResult = await this.apiService.sequencer.createProcess({
+      processId,
+      censusRoot,
+      ballotMode,
+      signature,
+      censusOrigin: config.census.type
+    });
+    const census = {
+      censusOrigin: config.census.type,
+      maxVotes: config.census.size.toString(),
+      censusRoot,
+      censusURI: config.census.uri
+    };
+    const encryptionKey = {
+      x: sequencerResult.encryptionPubKey[0],
+      y: sequencerResult.encryptionPubKey[1]
+    };
+    const txStream = this.processRegistry.newProcess(
+      ProcessStatus.READY,
+      startTime,
+      duration,
+      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
+    };
+  }
+  /**
+   * Validates and calculates timing parameters
+   */
+  calculateTiming(timing) {
+    const { startDate, duration, endDate } = timing;
+    if (duration !== void 0 && endDate !== void 0) {
+      throw new Error("Cannot specify both 'duration' and 'endDate'. Use one or the other.");
+    }
+    if (duration === void 0 && endDate === void 0) {
+      throw new Error("Must specify either 'duration' (in seconds) or 'endDate'.");
+    }
+    const startTime = startDate ? this.dateToUnixTimestamp(startDate) : Math.floor(Date.now() / 1e3) + 60;
+    let calculatedDuration;
+    if (duration !== void 0) {
+      calculatedDuration = duration;
+    } else {
+      const endTime = this.dateToUnixTimestamp(endDate);
+      calculatedDuration = endTime - startTime;
+      if (calculatedDuration <= 0) {
+        throw new Error("End date must be after start date.");
+      }
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (startTime < now - 30) {
+      throw new Error("Start date cannot be in the past.");
+    }
+    return { startTime, duration: calculatedDuration };
+  }
+  /**
+   * Converts various date formats to Unix timestamp
+   */
+  dateToUnixTimestamp(date) {
+    if (typeof date === "number") {
+      if (date > 1e10) {
+        return Math.floor(date / 1e3);
+      }
+      return Math.floor(date);
+    }
+    if (typeof date === "string") {
+      const parsed = new Date(date);
+      if (isNaN(parsed.getTime())) {
+        throw new Error(`Invalid date string: ${date}`);
+      }
+      return Math.floor(parsed.getTime() / 1e3);
+    }
+    if (date instanceof Date) {
+      if (isNaN(date.getTime())) {
+        throw new Error("Invalid Date object provided.");
+      }
+      return Math.floor(date.getTime() / 1e3);
+    }
+    throw new Error("Invalid date format. Use Date object, ISO string, or Unix timestamp.");
+  }
+  /**
+   * Creates metadata from the simplified configuration
+   */
+  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 || "" },
+      meta: {},
+      choices: q.choices.map((c) => ({
+        title: { default: c.title },
+        value: c.value,
+        meta: {}
+      }))
+    }));
+    return metadata;
+  }
+}
+
+class CircomProof {
+  constructor(opts = {}) {
+    // simple in-memory cache keyed by URL
+    this.wasmCache = /* @__PURE__ */ new Map();
+    this.zkeyCache = /* @__PURE__ */ new Map();
+    this.vkeyCache = /* @__PURE__ */ new Map();
+    this.wasmUrl = opts.wasmUrl;
+    this.zkeyUrl = opts.zkeyUrl;
+    this.vkeyUrl = opts.vkeyUrl;
+    this.wasmHash = opts.wasmHash;
+    this.zkeyHash = opts.zkeyHash;
+    this.vkeyHash = opts.vkeyHash;
+  }
+  /**
+   * Computes SHA-256 hash of the given data and compares it with the expected hash.
+   * @param data - The data to hash (string or ArrayBuffer or Uint8Array)
+   * @param expectedHash - The expected SHA-256 hash in hexadecimal format
+   * @param filename - The filename for error reporting
+   * @throws Error if the computed hash doesn't match the expected hash
+   */
+  verifyHash(data, expectedHash, filename) {
+    let bytes;
+    if (typeof data === "string") {
+      bytes = new TextEncoder().encode(data);
+    } else if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else {
+      bytes = data;
+    }
+    const computedHash = ethers.sha256(bytes).slice(2);
+    if (computedHash.toLowerCase() !== expectedHash.toLowerCase()) {
+      throw new Error(
+        `Hash verification failed for ${filename}. Expected: ${expectedHash.toLowerCase()}, Computed: ${computedHash.toLowerCase()}`
+      );
+    }
+  }
+  /**
+   * Generate a zk‐SNARK proof.
+   * If you didn't pass wasmUrl/zkeyUrl in the constructor you must supply them here.
+   */
+  async generate(inputs, urls = {}) {
+    const wasmUrl = urls.wasmUrl ?? this.wasmUrl;
+    const zkeyUrl = urls.zkeyUrl ?? this.zkeyUrl;
+    if (!wasmUrl) throw new Error("`wasmUrl` is required to generate a proof");
+    if (!zkeyUrl) throw new Error("`zkeyUrl` is required to generate a proof");
+    let wasmBin = this.wasmCache.get(wasmUrl);
+    if (!wasmBin) {
+      const r = await fetch(wasmUrl);
+      if (!r.ok) throw new Error(`Failed to fetch wasm at ${wasmUrl}: ${r.status}`);
+      const buf = await r.arrayBuffer();
+      wasmBin = new Uint8Array(buf);
+      if (this.wasmHash) {
+        this.verifyHash(wasmBin, this.wasmHash, "circuit.wasm");
+      }
+      this.wasmCache.set(wasmUrl, wasmBin);
+    }
+    let zkeyBin = this.zkeyCache.get(zkeyUrl);
+    if (!zkeyBin) {
+      const r = await fetch(zkeyUrl);
+      if (!r.ok) throw new Error(`Failed to fetch zkey at ${zkeyUrl}: ${r.status}`);
+      const buf = await r.arrayBuffer();
+      zkeyBin = new Uint8Array(buf);
+      if (this.zkeyHash) {
+        this.verifyHash(zkeyBin, this.zkeyHash, "proving_key.zkey");
+      }
+      this.zkeyCache.set(zkeyUrl, zkeyBin);
+    }
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      wasmBin,
+      zkeyBin
+    );
+    return {
+      proof,
+      publicSignals
+    };
+  }
+  async verify(proof, publicSignals, urlOverride) {
+    const vkeyUrl = urlOverride ?? this.vkeyUrl;
+    if (!vkeyUrl) throw new Error("`vkeyUrl` is required to verify a proof");
+    let vk = this.vkeyCache.get(vkeyUrl);
+    if (!vk) {
+      const r = await fetch(vkeyUrl);
+      if (!r.ok) throw new Error(`Failed to fetch vkey at ${vkeyUrl}: ${r.status}`);
+      const vkeyText = await r.text();
+      if (this.vkeyHash) {
+        this.verifyHash(vkeyText, this.vkeyHash, "verification_key.json");
+      }
+      vk = JSON.parse(vkeyText);
+      this.vkeyCache.set(vkeyUrl, vk);
+    }
+    return snarkjs.groth16.verify(vk, publicSignals, proof);
+  }
+}
+
+var VoteStatus = /* @__PURE__ */ ((VoteStatus2) => {
+  VoteStatus2["Pending"] = "pending";
+  VoteStatus2["Verified"] = "verified";
+  VoteStatus2["Aggregated"] = "aggregated";
+  VoteStatus2["Processed"] = "processed";
+  VoteStatus2["Settled"] = "settled";
+  VoteStatus2["Error"] = "error";
+  return VoteStatus2;
+})(VoteStatus || {});
+
+class VoteOrchestrationService {
+  constructor(apiService, getCrypto, signer, censusProviders = {}) {
+    this.apiService = apiService;
+    this.getCrypto = getCrypto;
+    this.signer = signer;
+    this.censusProviders = censusProviders;
+  }
+  /**
+   * Submit a vote with simplified configuration
+   * This method handles all the complex orchestration internally:
+   * - Fetches process information and encryption keys
+   * - Gets census proof (Merkle or CSP)
+   * - Generates cryptographic proofs
+   * - Signs and submits the vote
+   * 
+   * @param config - Simplified vote configuration
+   * @returns Promise resolving to vote submission result
+   */
+  async submitVote(config) {
+    const process = await this.apiService.sequencer.getProcess(config.processId);
+    if (!process.isAcceptingVotes) {
+      throw new Error("Process is not currently accepting votes");
+    }
+    const voterAddress = await this.signer.getAddress();
+    const censusProof = await this.getCensusProof(
+      process.census.censusOrigin,
+      process.census.censusRoot,
+      voterAddress,
+      config.processId
+    );
+    const { voteId, cryptoOutput, circomInputs } = await this.generateVoteProofInputs(
+      config.processId,
+      voterAddress,
+      process.encryptionKey,
+      process.ballotMode,
+      config.choices,
+      censusProof.weight,
+      config.randomness
+    );
+    const { proof } = await this.generateZkProof(circomInputs);
+    const signature = await this.signVote(voteId);
+    await this.submitVoteRequest({
+      processId: config.processId,
+      censusProof,
+      ballot: cryptoOutput.ballot,
+      ballotProof: proof,
+      ballotInputsHash: cryptoOutput.ballotInputsHash,
+      address: voterAddress,
+      signature,
+      voteId
+    });
+    const status = await this.apiService.sequencer.getVoteStatus(config.processId, voteId);
+    return {
+      voteId,
+      signature,
+      voterAddress,
+      processId: config.processId,
+      status: status.status
+    };
+  }
+  /**
+   * Get the status of a submitted vote
+   * 
+   * @param processId - The process ID
+   * @param voteId - The vote ID
+   * @returns Promise resolving to vote status information
+   */
+  async getVoteStatus(processId, voteId) {
+    const status = await this.apiService.sequencer.getVoteStatus(processId, voteId);
+    return {
+      voteId,
+      status: status.status,
+      processId
+    };
+  }
+  /**
+   * 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
+   */
+  async hasAddressVoted(processId, address) {
+    return this.apiService.sequencer.hasAddressVoted(processId, address);
+  }
+  /**
+   * Wait for a vote to reach a specific status
+   * 
+   * @param processId - The process ID
+   * @param voteId - The vote ID
+   * @param targetStatus - The target status to wait for (default: "settled")
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 300000 = 5 minutes)
+   * @param pollIntervalMs - Polling interval in milliseconds (default: 5000 = 5 seconds)
+   * @returns Promise resolving to final vote status
+   */
+  async waitForVoteStatus(processId, voteId, targetStatus = VoteStatus.Settled, timeoutMs = 3e5, pollIntervalMs = 5e3) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const statusInfo = await this.getVoteStatus(processId, voteId);
+      if (statusInfo.status === targetStatus || statusInfo.status === VoteStatus.Error) {
+        return statusInfo;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(`Vote did not reach status ${targetStatus} within ${timeoutMs}ms`);
+  }
+  /**
+   * Get census proof based on census origin type
+   */
+  async getCensusProof(censusOrigin, censusRoot, voterAddress, processId) {
+    if (censusOrigin === CensusOrigin.CensusOriginMerkleTree) {
+      if (this.censusProviders.merkle) {
+        const proof = await this.censusProviders.merkle({
+          censusRoot,
+          address: voterAddress
+        });
+        assertMerkleCensusProof(proof);
+        return proof;
+      } else {
+        const proof = await this.apiService.census.getCensusProof(censusRoot, voterAddress);
+        assertMerkleCensusProof(proof);
+        return proof;
+      }
+    }
+    if (censusOrigin === CensusOrigin.CensusOriginCSP) {
+      if (!this.censusProviders.csp) {
+        throw new Error(
+          "CSP voting requires a CSP census proof provider. Pass one via VoteOrchestrationService(..., { csp: yourFn })."
+        );
+      }
+      const proof = await this.censusProviders.csp({
+        processId,
+        address: voterAddress
+      });
+      assertCSPCensusProof(proof);
+      return proof;
+    }
+    throw new Error(`Unsupported census origin: ${censusOrigin}`);
+  }
+  /**
+   * Generate vote proof inputs using DavinciCrypto
+   */
+  async generateVoteProofInputs(processId, voterAddress, encryptionKey, ballotMode, choices, weight, customRandomness) {
+    const crypto = await this.getCrypto();
+    this.validateChoices(choices, ballotMode);
+    const fieldValues = choices.map((choice) => choice.toString());
+    const inputs = {
+      address: voterAddress.replace(/^0x/, ""),
+      processID: processId.replace(/^0x/, ""),
+      encryptionKey: [encryptionKey.x, encryptionKey.y],
+      ballotMode,
+      weight,
+      fieldValues
+    };
+    if (customRandomness) {
+      const hexRandomness = customRandomness.startsWith("0x") ? customRandomness : "0x" + customRandomness;
+      const k = BigInt(hexRandomness).toString();
+      inputs.k = k;
+    }
+    const cryptoOutput = await crypto.proofInputs(inputs);
+    return {
+      voteId: cryptoOutput.voteId,
+      cryptoOutput,
+      circomInputs: cryptoOutput.circomInputs
+    };
+  }
+  /**
+   * Validate user choices based on ballot mode
+   */
+  validateChoices(choices, ballotMode) {
+    const maxValue = parseInt(ballotMode.maxValue);
+    const minValue = parseInt(ballotMode.minValue);
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      if (choice < minValue || choice > maxValue) {
+        throw new Error(`Choice ${choice} is out of range [${minValue}, ${maxValue}]`);
+      }
+    }
+  }
+  /**
+   * Generate zk-SNARK proof using CircomProof
+   */
+  async generateZkProof(circomInputs) {
+    const info = await this.apiService.sequencer.getInfo();
+    const circomProof = new CircomProof({
+      wasmUrl: info.circuitUrl,
+      zkeyUrl: info.provingKeyUrl,
+      vkeyUrl: info.verificationKeyUrl
+    });
+    const { proof, publicSignals } = await circomProof.generate(circomInputs);
+    const isValid = await circomProof.verify(proof, publicSignals);
+    if (!isValid) {
+      throw new Error("Generated proof is invalid");
+    }
+    return { proof, publicSignals };
+  }
+  hexToBytes(hex) {
+    const clean = hex.replace(/^0x/, "");
+    if (clean.length % 2) throw new Error("Invalid hex length");
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < out.length; i++) out[i] = parseInt(clean.substr(i * 2, 2), 16);
+    return out;
+  }
+  /**
+   * Sign the vote using the signer
+   */
+  async signVote(voteId) {
+    return this.signer.signMessage(this.hexToBytes(voteId));
+  }
+  /**
+   * Submit the vote request to the sequencer
+   */
+  async submitVoteRequest(voteRequest) {
+    const ballotProof = {
+      pi_a: voteRequest.ballotProof.pi_a,
+      pi_b: voteRequest.ballotProof.pi_b,
+      pi_c: voteRequest.ballotProof.pi_c,
+      protocol: voteRequest.ballotProof.protocol
+    };
+    const request = {
+      ...voteRequest,
+      ballotProof
+    };
+    await this.apiService.sequencer.submitVote(request);
+  }
+}
+
+class OrganizationRegistryService extends SmartContractService {
+  constructor(contractAddress, runner) {
+    super();
+    this.contract = davinciContracts.OrganizationRegistry__factory.connect(
+      contractAddress,
+      runner
+    );
+  }
+  // ─── READ OPERATIONS ───────────────────────────────────────────────────────
+  async getOrganization(id) {
+    const { name, metadataURI } = await this.contract.getOrganization(id);
+    return { name, metadataURI };
+  }
+  async existsOrganization(id) {
+    return this.contract.exists(id);
+  }
+  async isAdministrator(id, address) {
+    return this.contract.isAdministrator(id, address);
+  }
+  async getOrganizationCount() {
+    const count = await this.contract.organizationCount();
+    return Number(count);
+  }
+  // ─── WRITE OPERATIONS ──────────────────────────────────────────────────────
+  createOrganization(name, metadataURI, administrators) {
+    return this.sendTx(
+      this.contract.createOrganization(name, metadataURI, administrators).catch((e) => {
+        throw new OrganizationCreateError(e.message, "create");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  updateOrganization(id, name, metadataURI) {
+    return this.sendTx(
+      this.contract.updateOrganization(id, name, metadataURI).catch((e) => {
+        throw new OrganizationUpdateError(e.message, "update");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  addAdministrator(id, administrator) {
+    return this.sendTx(
+      this.contract.addAdministrator(id, administrator).catch((e) => {
+        throw new OrganizationAdministratorError(e.message, "addAdministrator");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  removeAdministrator(id, administrator) {
+    return this.sendTx(
+      this.contract.removeAdministrator(id, administrator).catch((e) => {
+        throw new OrganizationAdministratorError(e.message, "removeAdministrator");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  deleteOrganization(id) {
+    return this.sendTx(
+      this.contract.deleteOrganization(id).catch((e) => {
+        throw new OrganizationDeleteError(e.message, "delete");
+      }),
+      async () => ({ success: true })
+    );
+  }
+  // ─── EVENT LISTENERS ───────────────────────────────────────────────────────
+  onOrganizationCreated(cb) {
+    this.contract.on(
+      this.contract.filters.OrganizationCreated(),
+      this.normalizeListener(cb)
+    );
+  }
+  onOrganizationUpdated(cb) {
+    this.contract.on(
+      this.contract.filters.OrganizationUpdated(),
+      this.normalizeListener(cb)
+    );
+  }
+  onAdministratorAdded(cb) {
+    this.contract.on(
+      this.contract.filters.AdministratorAdded(),
+      this.normalizeListener(cb)
+    );
+  }
+  onAdministratorRemoved(cb) {
+    this.contract.on(
+      this.contract.filters.AdministratorRemoved(),
+      this.normalizeListener(cb)
+    );
+  }
+  removeAllListeners() {
+    this.contract.removeAllListeners();
+  }
+}
+
+class DavinciCrypto {
+  constructor(opts) {
+    this.initialized = false;
+    const { wasmExecUrl, wasmUrl, initTimeoutMs, wasmExecHash, wasmHash } = opts;
+    if (!wasmExecUrl) throw new Error("`wasmExecUrl` is required");
+    if (!wasmUrl) throw new Error("`wasmUrl` is required");
+    this.wasmExecUrl = wasmExecUrl;
+    this.wasmUrl = wasmUrl;
+    this.initTimeoutMs = initTimeoutMs ?? 5e3;
+    this.wasmExecHash = wasmExecHash;
+    this.wasmHash = wasmHash;
+  }
+  static {
+    // Cache for wasm files
+    this.wasmExecCache = /* @__PURE__ */ new Map();
+  }
+  static {
+    this.wasmBinaryCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Computes SHA-256 hash of the given data and compares it with the expected hash.
+   * @param data - The data to hash (string or ArrayBuffer)
+   * @param expectedHash - The expected SHA-256 hash in hexadecimal format
+   * @param filename - The filename for error reporting
+   * @throws Error if the computed hash doesn't match the expected hash
+   */
+  verifyHash(data, expectedHash, filename) {
+    let bytes;
+    if (typeof data === "string") {
+      bytes = new TextEncoder().encode(data);
+    } else {
+      bytes = new Uint8Array(data);
+    }
+    const computedHash = ethers.sha256(bytes).slice(2);
+    if (computedHash.toLowerCase() !== expectedHash.toLowerCase()) {
+      throw new Error(
+        `Hash verification failed for ${filename}. Expected: ${expectedHash.toLowerCase()}, Computed: ${computedHash.toLowerCase()}`
+      );
+    }
+  }
+  /**
+   * Must be awaited before calling `proofInputs()`.
+   * Safe to call multiple times.
+   */
+  async init() {
+    if (this.initialized) return;
+    let shimCode = DavinciCrypto.wasmExecCache.get(this.wasmExecUrl);
+    if (!shimCode) {
+      const shim = await fetch(this.wasmExecUrl);
+      if (!shim.ok) {
+        throw new Error(`Failed to fetch wasm_exec.js from ${this.wasmExecUrl}`);
+      }
+      shimCode = await shim.text();
+      if (this.wasmExecHash) {
+        this.verifyHash(shimCode, this.wasmExecHash, "wasm_exec.js");
+      }
+      DavinciCrypto.wasmExecCache.set(this.wasmExecUrl, shimCode);
+    }
+    new Function(shimCode)();
+    if (typeof globalThis.Go !== "function") {
+      throw new Error("Global `Go` constructor not found after loading wasm_exec.js");
+    }
+    this.go = new globalThis.Go();
+    let bytes = DavinciCrypto.wasmBinaryCache.get(this.wasmUrl);
+    if (!bytes) {
+      const resp = await fetch(this.wasmUrl);
+      if (!resp.ok) {
+        throw new Error(`Failed to fetch ballotproof.wasm from ${this.wasmUrl}`);
+      }
+      bytes = await resp.arrayBuffer();
+      if (this.wasmHash) {
+        this.verifyHash(bytes, this.wasmHash, "davinci_crypto.wasm");
+      }
+      DavinciCrypto.wasmBinaryCache.set(this.wasmUrl, bytes);
+    }
+    const { instance } = await WebAssembly.instantiate(bytes, this.go.importObject);
+    this.go.run(instance).catch(() => {
+    });
+    const deadline = Date.now() + this.initTimeoutMs;
+    while (Date.now() < deadline && !globalThis.DavinciCrypto) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    if (!globalThis.DavinciCrypto) {
+      throw new Error("`DavinciCrypto` not initialized within timeout");
+    }
+    this.initialized = true;
+  }
+  /**
+   * Convert your inputs into JSON, hand off to Go/WASM, then parse & return.
+   * @throws if called before `await init()`, or if Go returns an error
+   */
+  async proofInputs(inputs) {
+    if (!this.initialized) {
+      throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
+    }
+    const raw = globalThis.DavinciCrypto.proofInputs(JSON.stringify(inputs));
+    if (raw.error) {
+      throw new Error(`Go/WASM proofInputs error: ${raw.error}`);
+    }
+    if (!raw.data) {
+      throw new Error("Go/WASM proofInputs returned no data");
+    }
+    return raw.data;
+  }
+  /**
+   * Generate a CSP (Credential Service Provider) signature for census proof.
+   * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+   * @param privKey - The private key in hex format
+   * @param processId - The process ID in hex format
+   * @param address - The address in hex format
+   * @returns The CSP proof as a parsed JSON object
+   * @throws if called before `await init()`, or if Go returns an error
+   */
+  async cspSign(censusOrigin, privKey, processId, address) {
+    if (!this.initialized) {
+      throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
+    }
+    const raw = globalThis.DavinciCrypto.cspSign(censusOrigin, privKey, processId, address);
+    if (raw.error) {
+      throw new Error(`Go/WASM cspSign error: ${raw.error}`);
+    }
+    if (!raw.data) {
+      throw new Error("Go/WASM cspSign returned no data");
+    }
+    return raw.data;
+  }
+  /**
+   * Verify a CSP (Credential Service Provider) proof.
+   * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+   * @param root - The census root
+   * @param address - The address
+   * @param processId - The process ID
+   * @param publicKey - The public key
+   * @param signature - The signature
+   * @returns The verification result
+   * @throws if called before `await init()`, or if Go returns an error
+   */
+  async cspVerify(censusOrigin, root, address, processId, publicKey, signature) {
+    if (!this.initialized) {
+      throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
+    }
+    const cspProof = {
+      censusOrigin,
+      root,
+      address,
+      processId,
+      publicKey,
+      signature
+    };
+    const raw = globalThis.DavinciCrypto.cspVerify(JSON.stringify(cspProof));
+    if (raw.error) {
+      throw new Error(`Go/WASM cspVerify error: ${raw.error}`);
+    }
+    if (!raw.data) {
+      throw new Error("Go/WASM cspVerify returned no data");
+    }
+    return raw.data;
+  }
+  /**
+   * Generate a CSP (Credential Service Provider) census root.
+   * @param censusOrigin - The census origin type (e.g., CensusOrigin.CensusOriginCSP)
+   * @param privKey - The private key in hex format
+   * @returns The census root as a hexadecimal string
+   * @throws if called before `await init()`, or if Go returns an error
+   */
+  async cspCensusRoot(censusOrigin, privKey) {
+    if (!this.initialized) {
+      throw new Error("DavinciCrypto not initialized \u2014 call `await init()` first");
+    }
+    const raw = globalThis.DavinciCrypto.cspCensusRoot(censusOrigin, privKey);
+    if (raw.error) {
+      throw new Error(`Go/WASM cspCensusRoot error: ${raw.error}`);
+    }
+    if (!raw.data) {
+      throw new Error("Go/WASM cspCensusRoot returned no data");
+    }
+    return raw.data.root;
+  }
+}
+
+class DavinciSDK {
+  constructor(config) {
+    this.initialized = false;
+    const resolvedConfig = resolveConfiguration({
+      environment: config.environment,
+      customUrls: {
+        sequencer: config.sequencerUrl,
+        census: config.censusUrl
+      },
+      customChain: config.chain
+    });
+    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
+    };
+    this.apiService = new VocdoniApiService({
+      sequencerURL: this.config.sequencerUrl,
+      censusURL: this.config.censusUrl
+    });
+    this.censusProviders = config.censusProviders || {};
+  }
+  /**
+   * Initialize the SDK and all its components
+   * This must be called before using any SDK functionality
+   */
+  async init() {
+    if (this.initialized) return;
+    if (this.config.useSequencerAddresses) {
+      await this.updateContractAddressesFromSequencer();
+    }
+    this.initialized = true;
+  }
+  /**
+   * Get the API service for direct access to sequencer and census APIs
+   */
+  get api() {
+    return this.apiService;
+  }
+  /**
+   * Get the process registry service for process management
+   */
+  get processes() {
+    if (!this._processRegistry) {
+      const processRegistryAddress = this.resolveContractAddress("processRegistry");
+      this._processRegistry = new ProcessRegistryService(processRegistryAddress, this.config.signer);
+    }
+    return this._processRegistry;
+  }
+  /**
+   * Get the organization registry service for organization management
+   */
+  get organizations() {
+    if (!this._organizationRegistry) {
+      const organizationRegistryAddress = this.resolveContractAddress("organizationRegistry");
+      this._organizationRegistry = new OrganizationRegistryService(organizationRegistryAddress, this.config.signer);
+    }
+    return this._organizationRegistry;
+  }
+  /**
+   * Get or initialize the DavinciCrypto service for cryptographic operations
+   */
+  async getCrypto() {
+    if (!this.davinciCrypto) {
+      const info = await this.apiService.sequencer.getInfo();
+      this.davinciCrypto = new DavinciCrypto({
+        wasmExecUrl: info.ballotProofWasmHelperExecJsUrl,
+        wasmUrl: info.ballotProofWasmHelperUrl
+      });
+      await this.davinciCrypto.init();
+    }
+    return this.davinciCrypto;
+  }
+  /**
+   * Get the process orchestration service for simplified process creation
+   */
+  get processOrchestrator() {
+    if (!this._processOrchestrator) {
+      this._processOrchestrator = new ProcessOrchestrationService(
+        this.processes,
+        this.apiService,
+        this.organizations,
+        () => this.getCrypto(),
+        this.config.signer
+      );
+    }
+    return this._processOrchestrator;
+  }
+  /**
+   * Get the vote orchestration service for simplified voting
+   */
+  get voteOrchestrator() {
+    if (!this._voteOrchestrator) {
+      this._voteOrchestrator = new VoteOrchestrationService(
+        this.apiService,
+        () => this.getCrypto(),
+        this.config.signer,
+        this.censusProviders
+      );
+    }
+    return this._voteOrchestrator;
+  }
+  /**
+   * 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.
+   * 
+   * @param processId - The process ID to fetch
+   * @returns Promise resolving to user-friendly process information
+   * 
+   * @example
+   * ```typescript
+   * const processInfo = await sdk.getProcess("0x1234567890abcdef...");
+   * 
+   * // Access the same fields as ProcessConfig
+   * console.log("Title:", processInfo.title);
+   * console.log("Description:", processInfo.description);
+   * console.log("Questions:", processInfo.questions);
+   * console.log("Census size:", processInfo.census.size);
+   * console.log("Ballot config:", processInfo.ballot);
+   * 
+   * // Plus additional runtime information
+   * console.log("Status:", processInfo.status);
+   * console.log("Creator:", processInfo.creator);
+   * console.log("Start date:", processInfo.startDate);
+   * console.log("End date:", processInfo.endDate);
+   * console.log("Duration:", processInfo.duration, "seconds");
+   * console.log("Time remaining:", processInfo.timeRemaining, "seconds");
+   * 
+   * // Access raw contract data if needed
+   * console.log("Raw data:", processInfo.raw);
+   * ```
+   */
+  async getProcess(processId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before getting processes. Call sdk.init() first.");
+    }
+    return this.processOrchestrator.getProcess(processId);
+  }
+  /**
+   * Creates a complete voting process with minimal configuration.
+   * This is the ultra-easy method for end users that handles all the complex orchestration internally.
+   * 
+   * 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
+   * 
+   * @example
+   * ```typescript
+   * // Option 1: Using duration (traditional approach)
+   * const result1 = await sdk.createProcess({
+   *   title: "My Election",
+   *   description: "A simple election",
+   *   census: {
+   *     type: CensusOrigin.CensusOriginMerkleTree,
+   *     root: "0x1234...",
+   *     size: 100,
+   *     uri: "ipfs://your-census-uri"
+   *   },
+   *   ballot: {
+   *     numFields: 2,
+   *     maxValue: "3",
+   *     minValue: "0",
+   *     uniqueValues: false,
+   *     costFromWeight: false,
+   *     costExponent: 10000,
+   *     maxValueSum: "6",
+   *     minValueSum: "0"
+   *   },
+   *   timing: {
+   *     startDate: new Date("2024-12-01T10:00:00Z"),
+   *     duration: 3600 * 24
+   *   },
+   *   questions: [
+   *     {
+   *       title: "What is your favorite color?",
+   *       choices: [
+   *         { title: "Red", value: 0 },
+   *         { title: "Blue", value: 1 }
+   *       ]
+   *     }
+   *   ]
+   * });
+   * 
+   * // Option 2: Using start and end dates
+   * const result2 = await sdk.createProcess({
+   *   title: "Weekend Vote",
+   *   timing: {
+   *     startDate: "2024-12-07T09:00:00Z",
+   *     endDate: "2024-12-08T18:00:00Z"
+   *   }
+   * });
+   * ```
+   */
+  async createProcess(config) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before creating processes. Call sdk.init() first.");
+    }
+    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.
+   * 
+   * The method automatically:
+   * - Fetches process information and validates voting is allowed
+   * - Gets census proof (Merkle tree based)
+   * - Generates cryptographic proofs and encrypts the vote
+   * - Signs and submits the vote to the sequencer
+   * 
+   * @param config - Simplified vote configuration
+   * @returns Promise resolving to vote submission result
+   * 
+   * @example
+   * ```typescript
+   * // Submit a vote with voter's private key
+   * const voteResult = await sdk.submitVote({
+   *   processId: "0x1234567890abcdef...",
+   *   choices: [1, 0], // Vote for option 1 in question 1, option 0 in question 2
+   *   voterKey: "0x1234567890abcdef..." // Voter's private key
+   * });
+   * 
+   * console.log("Vote ID:", voteResult.voteId);
+   * console.log("Status:", voteResult.status);
+   * 
+   * // Submit a vote with a Wallet instance
+   * import { Wallet } from "ethers";
+   * const voterWallet = new Wallet("0x...");
+   * 
+   * const voteResult2 = await sdk.submitVote({
+   *   processId: "0x1234567890abcdef...",
+   *   choices: [2], // Single question vote
+   *   voterKey: voterWallet
+   * });
+   * ```
+   */
+  async submitVote(config) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before submitting votes. Call sdk.init() first.");
+    }
+    return this.voteOrchestrator.submitVote(config);
+  }
+  /**
+   * Get the status of a submitted vote.
+   * 
+   * @param processId - The process ID
+   * @param voteId - The vote ID returned from submitVote()
+   * @returns Promise resolving to vote status information
+   * 
+   * @example
+   * ```typescript
+   * const statusInfo = await sdk.getVoteStatus(processId, voteId);
+   * console.log("Vote status:", statusInfo.status);
+   * // Possible statuses: "pending", "verified", "aggregated", "processed", "settled", "error"
+   * ```
+   */
+  async getVoteStatus(processId, voteId) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before getting vote status. Call sdk.init() first.");
+    }
+    return this.voteOrchestrator.getVoteStatus(processId, voteId);
+  }
+  /**
+   * 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
+   * 
+   * @example
+   * ```typescript
+   * const hasVoted = await sdk.hasAddressVoted(processId, "0x1234567890abcdef...");
+   * if (hasVoted) {
+   *   console.log("This address has already voted");
+   * }
+   * ```
+   */
+  async hasAddressVoted(processId, address) {
+    if (!this.initialized) {
+      throw new Error("SDK must be initialized before checking vote status. Call sdk.init() first.");
+    }
+    return this.voteOrchestrator.hasAddressVoted(processId, address);
+  }
+  /**
+   * Wait for a vote to reach a specific status.
+   * Useful for waiting for vote confirmation and processing.
+   * 
+   * @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..."
+   * });
+   * 
+   * // Wait for the vote to be fully processed
+   * const finalStatus = await sdk.waitForVoteStatus(
+   *   voteResult.processId,
+   *   voteResult.voteId,
+   *   "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.");
+    }
+    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
+   */
+  resolveContractAddress(contractName) {
+    if (this.config.useSequencerAddresses) {
+      return this.getDefaultContractAddress(contractName);
+    }
+    const customAddress = this.config.contractAddresses[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}`);
+    }
+  }
+  /**
+   * Update contract addresses from sequencer info if useSequencerAddresses is enabled
+   * Sequencer addresses have priority over user-provided addresses
+   */
+  async updateContractAddressesFromSequencer() {
+    try {
+      const info = await this.apiService.sequencer.getInfo();
+      const contracts = info.contracts;
+      if (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;
+      }
+      if (contracts.stateTransitionVerifier) {
+        this.config.contractAddresses.stateTransitionVerifier = contracts.stateTransitionVerifier;
+      }
+      if (contracts.resultsVerifier) {
+        this.config.contractAddresses.resultsVerifier = contracts.resultsVerifier;
+      }
+    } catch (error) {
+      console.warn("Failed to fetch contract addresses from sequencer, using defaults:", error);
+    }
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check if the SDK has been initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+}
+
+exports.BaseService = BaseService;
+exports.CensusOrigin = CensusOrigin;
+exports.CircomProof = CircomProof;
+exports.ContractServiceError = ContractServiceError;
+exports.DEFAULT_ENVIRONMENT_URLS = DEFAULT_ENVIRONMENT_URLS;
+exports.DavinciCrypto = DavinciCrypto;
+exports.DavinciSDK = DavinciSDK;
+exports.ElectionMetadataTemplate = ElectionMetadataTemplate;
+exports.ElectionResultsTypeNames = ElectionResultsTypeNames;
+exports.OrganizationAdministratorError = OrganizationAdministratorError;
+exports.OrganizationCreateError = OrganizationCreateError;
+exports.OrganizationDeleteError = OrganizationDeleteError;
+exports.OrganizationRegistryService = OrganizationRegistryService;
+exports.OrganizationUpdateError = OrganizationUpdateError;
+exports.ProcessCensusError = ProcessCensusError;
+exports.ProcessCreateError = ProcessCreateError;
+exports.ProcessDurationError = ProcessDurationError;
+exports.ProcessOrchestrationService = ProcessOrchestrationService;
+exports.ProcessRegistryService = ProcessRegistryService;
+exports.ProcessResultError = ProcessResultError;
+exports.ProcessStateTransitionError = ProcessStateTransitionError;
+exports.ProcessStatus = ProcessStatus;
+exports.ProcessStatusError = ProcessStatusError;
+exports.SmartContractService = SmartContractService;
+exports.TxStatus = TxStatus;
+exports.VocdoniApiService = VocdoniApiService;
+exports.VocdoniCensusService = VocdoniCensusService;
+exports.VocdoniSequencerService = VocdoniSequencerService;
+exports.VoteOrchestrationService = VoteOrchestrationService;
+exports.VoteStatus = VoteStatus;
+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