@vocdoni/davinci-sdk 0.0.5 → 0.0.7

package/dist/index.umd.js

@@ -193,18 +193,20 @@
   }
 
   var CensusOrigin = /* @__PURE__ */ ((CensusOrigin2) => {
-    CensusOrigin2[CensusOrigin2["CensusOriginMerkleTree"] = 1] = "CensusOriginMerkleTree";
-    CensusOrigin2[CensusOrigin2["CensusOriginCSP"] = 2] = "CensusOriginCSP";
+    CensusOrigin2[CensusOrigin2["OffchainStatic"] = 1] = "OffchainStatic";
+    CensusOrigin2[CensusOrigin2["OffchainDynamic"] = 2] = "OffchainDynamic";
+    CensusOrigin2[CensusOrigin2["Onchain"] = 3] = "Onchain";
+    CensusOrigin2[CensusOrigin2["CSP"] = 4] = "CSP";
     return CensusOrigin2;
   })(CensusOrigin || {});
   function isBaseCensusProof(proof) {
     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.weight === "string" && typeof proof.value === "string" && typeof proof.siblings === "string";
+    return isBaseCensusProof(proof) && (proof.censusOrigin === 1 /* OffchainStatic */ || proof.censusOrigin === 2 /* OffchainDynamic */ || proof.censusOrigin === 3 /* Onchain */) && typeof proof.weight === "string" && typeof proof.value === "string" && typeof proof.siblings === "string";
   }
   function isCSPCensusProof(proof) {
-    return isBaseCensusProof(proof) && proof.censusOrigin === 2 /* CensusOriginCSP */ && typeof proof.weight === "string" && typeof proof.processId === "string" && typeof proof.publicKey === "string" && typeof proof.signature === "string";
+    return isBaseCensusProof(proof) && proof.censusOrigin === 4 /* CSP */ && typeof proof.weight === "string" && typeof proof.processId === "string" && typeof proof.publicKey === "string" && typeof proof.signature === "string";
   }
   function assertMerkleCensusProof(proof) {
     if (!isMerkleCensusProof(proof)) {
@@ -224,12 +226,27 @@
     return CensusType2;
   })(CensusType || {});
   class Census {
-    constructor(type) {
+    constructor(type, censusOrigin) {
       this._censusId = null;
       this._censusRoot = null;
       this._censusURI = null;
       this._size = null;
       this._type = type;
+      if (censusOrigin !== void 0) {
+        this._censusOrigin = censusOrigin;
+      } else {
+        switch (type) {
+          case "plain" /* PLAIN */:
+          case "weighted" /* WEIGHTED */:
+            this._censusOrigin = CensusOrigin.OffchainStatic;
+            break;
+          case "csp" /* CSP */:
+            this._censusOrigin = CensusOrigin.CSP;
+            break;
+          default:
+            throw new Error(`Unknown census type: ${type}`);
+        }
+      }
     }
     get censusId() {
       return this._censusId;
@@ -250,24 +267,20 @@
       return this._censusRoot !== null && this._censusURI !== null;
     }
     /**
-     * Convert CensusType to CensusOrigin enum for API compatibility
+     * Get the census origin (OffchainStatic, OffchainDynamic, Onchain, or CSP)
      */
     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}`);
-      }
+      return this._censusOrigin;
     }
   }
 
   class PlainCensus extends Census {
-    constructor() {
-      super(CensusType.PLAIN);
+    /**
+     * Creates a new PlainCensus
+     * @param censusOrigin - The census origin (defaults to OffchainStatic for backward compatibility)
+     */
+    constructor(censusOrigin) {
+      super(CensusType.PLAIN, censusOrigin);
       this._participants = /* @__PURE__ */ new Set();
     }
     /**
@@ -325,8 +338,12 @@
   }
 
   class WeightedCensus extends Census {
-    constructor() {
-      super(CensusType.WEIGHTED);
+    /**
+     * Creates a new WeightedCensus
+     * @param censusOrigin - The census origin (defaults to OffchainStatic for backward compatibility)
+     */
+    constructor(censusOrigin) {
+      super(CensusType.WEIGHTED, censusOrigin);
       this._participants = /* @__PURE__ */ new Map();
     }
     /**
@@ -418,7 +435,7 @@
 
   class CspCensus extends Census {
     constructor(publicKey, cspURI, size) {
-      super(CensusType.CSP);
+      super(CensusType.CSP, CensusOrigin.CSP);
       if (!/^(0x)?[0-9a-fA-F]+$/.test(publicKey)) {
         throw new Error("Public key is missing or invalid");
       }
@@ -442,8 +459,16 @@
   }
 
   class PublishedCensus extends Census {
-    constructor(type, root, uri, size) {
-      super(type);
+    /**
+     * Creates a PublishedCensus from existing census data
+     * @param type - The census type (PLAIN, WEIGHTED, or CSP)
+     * @param root - The census root
+     * @param uri - The census URI
+     * @param size - The census size (number of participants)
+     * @param censusOrigin - The census origin (optional - defaults based on type if not provided)
+     */
+    constructor(type, root, uri, size, censusOrigin) {
+      super(type, censusOrigin);
       this._censusRoot = root;
       this._censusURI = uri;
       this._size = size;
@@ -942,6 +967,8 @@
   }
   class ProcessCensusError extends ContractServiceError {
   }
+  class CensusNotUpdatable extends ContractServiceError {
+  }
   class ProcessDurationError extends ContractServiceError {
   }
   class ProcessStateTransitionError extends ContractServiceError {
@@ -1005,7 +1032,7 @@
       return this.contract.stVerifier();
     }
     // ─── WRITES ────────────────────────────────────────────────────────
-    newProcess(status, startTime, duration, ballotMode, census, metadata, encryptionKey, initStateRoot) {
+    newProcess(status, startTime, duration, maxVoters, ballotMode, census, metadata, encryptionKey, initStateRoot) {
       const contractCensus = {
         censusOrigin: BigInt(census.censusOrigin),
         censusRoot: census.censusRoot,
@@ -1016,6 +1043,7 @@
           status,
           startTime,
           duration,
+          maxVoters,
           ballotMode,
           contractCensus,
           metadata,
@@ -1056,6 +1084,14 @@
         async () => ({ success: true })
       );
     }
+    setProcessMaxVoters(processID, maxVoters) {
+      return this.sendTx(
+        this.contract.setProcessMaxVoters(processID, maxVoters).catch((e) => {
+          throw new ProcessDurationError(e.message, "setMaxVoters");
+        }),
+        async () => ({ success: true })
+      );
+    }
     /**
      * Matches the on-chain `submitStateTransition(processId, proof, input)`
      */
@@ -1112,12 +1148,12 @@
         cb
       ).catch((err) => console.error("Error setting up ProcessDurationChanged listener:", err));
     }
-    onStateRootUpdated(cb) {
+    onStateTransitioned(cb) {
       this.setupEventListener(
         this.contract,
-        this.contract.filters.ProcessStateRootUpdated(),
+        this.contract.filters.ProcessStateTransitioned(),
         cb
-      ).catch((err) => console.error("Error setting up StateRootUpdated listener:", err));
+      ).catch((err) => console.error("Error setting up ProcessStateTransitioned listener:", err));
     }
     onProcessResultsSet(cb) {
       this.setupEventListener(
@@ -1126,6 +1162,13 @@
         cb
       ).catch((err) => console.error("Error setting up ProcessResultsSet listener:", err));
     }
+    onProcessMaxVotersChanged(cb) {
+      this.setupEventListener(
+        this.contract,
+        this.contract.filters.ProcessMaxVotersChanged(),
+        cb
+      ).catch((err) => console.error("Error setting up ProcessMaxVotersChanged listener:", err));
+    }
     removeAllListeners() {
       this.contract.removeAllListeners();
       this.clearPollingIntervals();
@@ -1231,6 +1274,7 @@
         endDate: new Date(endTime * 1e3),
         duration,
         timeRemaining,
+        maxVoters: Number(rawProcess.maxVoters),
         result: rawProcess.result,
         votersCount: Number(rawProcess.votersCount),
         overwrittenVotesCount: Number(rawProcess.overwrittenVotesCount),
@@ -1285,6 +1329,7 @@
         ProcessStatus.READY,
         data.startTime,
         data.duration,
+        data.maxVoters,
         data.ballotMode,
         data.census,
         data.metadataUri,
@@ -1372,6 +1417,7 @@
         ballotMode,
         signature
       });
+      const maxVoters = config.maxVoters ?? censusConfig.size;
       const census = {
         censusOrigin: censusConfig.type,
         censusRoot,
@@ -1381,6 +1427,7 @@
         processId,
         startTime,
         duration,
+        maxVoters,
         censusRoot,
         ballotMode,
         metadataUri,
@@ -1767,6 +1814,84 @@
       }
       throw new Error("Resume process stream ended unexpectedly");
     }
+    /**
+     * Sets the maximum number of voters for a process.
+     * Returns an async generator that yields transaction status events.
+     *
+     * @param processId - The process ID
+     * @param maxVoters - The new maximum number of voters
+     * @returns AsyncGenerator yielding transaction status events
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.setProcessMaxVotersStream("0x1234567890abcdef...", 500);
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case "pending":
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case "completed":
+     *       console.log("MaxVoters updated successfully");
+     *       break;
+     *     case "failed":
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case "reverted":
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    async *setProcessMaxVotersStream(processId, maxVoters) {
+      const txStream = this.processRegistry.setProcessMaxVoters(processId, maxVoters);
+      for await (const event of txStream) {
+        if (event.status === TxStatus.Pending) {
+          yield { status: TxStatus.Pending, hash: event.hash };
+        } else if (event.status === TxStatus.Completed) {
+          yield {
+            status: TxStatus.Completed,
+            response: { success: true }
+          };
+          break;
+        } else if (event.status === TxStatus.Failed) {
+          yield { status: TxStatus.Failed, error: event.error };
+          break;
+        } else if (event.status === TxStatus.Reverted) {
+          yield { status: TxStatus.Reverted, reason: event.reason };
+          break;
+        }
+      }
+    }
+    /**
+     * Sets the maximum number of voters for a process.
+     * This is a simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use setProcessMaxVotersStream() instead.
+     *
+     * @param processId - The process ID
+     * @param maxVoters - The new maximum number of voters
+     * @returns Promise resolving when the maxVoters is updated
+     *
+     * @example
+     * ```typescript
+     * await sdk.setProcessMaxVoters("0x1234567890abcdef...", 500);
+     * console.log("MaxVoters updated successfully");
+     * ```
+     */
+    async setProcessMaxVoters(processId, maxVoters) {
+      for await (const event of this.setProcessMaxVotersStream(processId, maxVoters)) {
+        if (event.status === "completed") {
+          return;
+        } else if (event.status === "failed") {
+          throw event.error;
+        } else if (event.status === "reverted") {
+          throw new Error(`Transaction reverted: ${event.reason || "unknown reason"}`);
+        }
+      }
+      throw new Error("Set process maxVoters stream ended unexpectedly");
+    }
   }
 
   class CircomProof {
@@ -1922,7 +2047,7 @@
         signature,
         voteId
       };
-      if (process.census.censusOrigin === CensusOrigin.CensusOriginCSP) {
+      if (process.census.censusOrigin === CensusOrigin.CSP) {
         voteRequest.censusProof = censusProof;
       }
       await this.submitVoteRequest(voteRequest);
@@ -2038,7 +2163,7 @@
      * Get census proof based on census origin type
      */
     async getCensusProof(censusOrigin, censusRoot, voterAddress, processId) {
-      if (censusOrigin === CensusOrigin.CensusOriginMerkleTree) {
+      if (censusOrigin === CensusOrigin.OffchainStatic || censusOrigin === CensusOrigin.OffchainDynamic || censusOrigin === CensusOrigin.Onchain) {
         if (this.censusProviders.merkle) {
           const proof = await this.censusProviders.merkle({
             censusRoot,
@@ -2052,13 +2177,13 @@
             root: censusRoot,
             address: voterAddress,
             weight,
-            censusOrigin: CensusOrigin.CensusOriginMerkleTree,
+            censusOrigin,
             value: "",
             siblings: ""
           };
         }
       }
-      if (censusOrigin === CensusOrigin.CensusOriginCSP) {
+      if (censusOrigin === CensusOrigin.CSP) {
         if (!this.censusProviders.csp) {
           throw new Error(
             "CSP voting requires a CSP census proof provider. Pass one via VoteOrchestrationService(..., { csp: yourFn })."
@@ -2632,7 +2757,7 @@
      *   title: "My Election",
      *   description: "A simple election",
      *   census: {
-     *     type: CensusOrigin.CensusOriginMerkleTree,
+     *     type: CensusOrigin.OffchainStatic,
      *     root: "0x1234...",
      *     size: 100,
      *     uri: "ipfs://..."
@@ -2719,7 +2844,7 @@
      *   title: "My Election",
      *   description: "A simple election",
      *   census: {
-     *     type: CensusOrigin.CensusOriginMerkleTree,
+     *     type: CensusOrigin.OffchainStatic,
      *     root: "0x1234...",
      *     size: 100,
      *     uri: "ipfs://your-census-uri"
@@ -3271,6 +3396,77 @@
       this.ensureProvider();
       return this.processOrchestrator.resumeProcess(processId);
     }
+    /**
+     * Sets the maximum number of voters for a process and returns an async generator
+     * that yields transaction status events. This allows you to change the voter limit
+     * after process creation.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID
+     * @param maxVoters - The new maximum number of voters
+     * @returns AsyncGenerator yielding transaction status events
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * const stream = sdk.setProcessMaxVotersStream("0x1234567890abcdef...", 500);
+     *
+     * for await (const event of stream) {
+     *   switch (event.status) {
+     *     case TxStatus.Pending:
+     *       console.log("Transaction pending:", event.hash);
+     *       break;
+     *     case TxStatus.Completed:
+     *       console.log("MaxVoters updated successfully");
+     *       break;
+     *     case TxStatus.Failed:
+     *       console.error("Transaction failed:", event.error);
+     *       break;
+     *     case TxStatus.Reverted:
+     *       console.error("Transaction reverted:", event.reason);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    setProcessMaxVotersStream(processId, maxVoters) {
+      if (!this.initialized) {
+        throw new Error(
+          "SDK must be initialized before setting process maxVoters. Call sdk.init() first."
+        );
+      }
+      this.ensureProvider();
+      return this.processOrchestrator.setProcessMaxVotersStream(processId, maxVoters);
+    }
+    /**
+     * Sets the maximum number of voters for a process.
+     * This is the simplified method that waits for transaction completion.
+     *
+     * For real-time transaction status updates, use setProcessMaxVotersStream() instead.
+     *
+     * Requires a signer with a provider for blockchain interactions.
+     *
+     * @param processId - The process ID
+     * @param maxVoters - The new maximum number of voters
+     * @returns Promise resolving when the maxVoters is updated
+     * @throws Error if signer does not have a provider
+     *
+     * @example
+     * ```typescript
+     * await sdk.setProcessMaxVoters("0x1234567890abcdef...", 500);
+     * console.log("MaxVoters updated successfully");
+     * ```
+     */
+    async setProcessMaxVoters(processId, maxVoters) {
+      if (!this.initialized) {
+        throw new Error(
+          "SDK must be initialized before setting process maxVoters. Call sdk.init() first."
+        );
+      }
+      this.ensureProvider();
+      return this.processOrchestrator.setProcessMaxVoters(processId, maxVoters);
+    }
     /**
      * Resolve contract address based on configuration priority:
      * 1. Custom addresses from user config (if provided)
@@ -3347,6 +3543,7 @@
 
   exports.BaseService = BaseService;
   exports.Census = Census;
+  exports.CensusNotUpdatable = CensusNotUpdatable;
   exports.CensusOrchestrator = CensusOrchestrator;
   exports.CensusOrigin = CensusOrigin;
   exports.CensusType = CensusType;

package/dist/sequencer.d.ts

@@ -99,10 +99,14 @@ declare class BaseService {
  * Census origin types
  */
 declare enum CensusOrigin {
-    /** Indicates that the census is derived from a Merkle Tree structure */
-    CensusOriginMerkleTree = 1,
-    /** Indicates that the census is provided by a Credential Service Provider (CSP) */
-    CensusOriginCSP = 2
+    /** Offchain static Merkle Tree census */
+    OffchainStatic = 1,
+    /** Offchain dynamic Merkle Tree census */
+    OffchainDynamic = 2,
+    /** Onchain Merkle Tree census */
+    Onchain = 3,
+    /** Credential Service Provider (CSP) census using EdDSA BLS12-377 */
+    CSP = 4
 }
 interface BaseCensusProof {
     /** The Merkle root (hex-prefixed). */
@@ -111,18 +115,18 @@ interface BaseCensusProof {
     address: string;
     /** The weight as a decimal string. */
     weight: string;
-    /** Census origin type: CensusOriginMerkleTree for merkle proofs, CensusOriginCSP for csp proofs */
+    /** Census origin type: OffchainStatic/OffchainDynamic/Onchain for merkle proofs, CSP for csp proofs */
     censusOrigin: CensusOrigin;
 }
 interface MerkleCensusProof extends BaseCensusProof {
-    censusOrigin: CensusOrigin.CensusOriginMerkleTree;
+    censusOrigin: CensusOrigin.OffchainStatic | CensusOrigin.OffchainDynamic | CensusOrigin.Onchain;
     /** The leaf value (hex-prefixed weight). */
     value: string;
     /** The serialized sibling path (hex-prefixed). */
     siblings: string;
 }
 interface CSPCensusProof extends BaseCensusProof {
-    censusOrigin: CensusOrigin.CensusOriginCSP;
+    censusOrigin: CensusOrigin.CSP;
     /** The process id signed with the address (hex-prefixed). */
     processId: string;
     /** The public key of the csp (hex-prefixed). */
@@ -181,6 +185,7 @@ interface GetProcessResponse {
     ballotMode: BallotMode;
     census: CensusData;
     votersCount: string;
+    maxVoters: string;
     overwrittenVotesCount: string;
     isAcceptingVotes: boolean;
     sequencerStats: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vocdoni/davinci-sdk",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@ethereumjs/common": "^4.4.0",
-    "@vocdoni/davinci-contracts": "0.0.28",
+    "@vocdoni/davinci-contracts": "0.0.31",
     "axios": "^1.8.4",
     "ethers": "^6.7.1",
     "snarkjs": "^0.7.5"