@vocdoni/davinci-sdk 0.0.5 → 0.0.7

package/dist/index.js

@@ -194,18 +194,20 @@ class VocdoniCensusService extends BaseService {
 }
 
 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)) {
@@ -225,12 +227,27 @@ var CensusType = /* @__PURE__ */ ((CensusType2) => {
   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;
@@ -251,24 +268,20 @@ class Census {
     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();
   }
   /**
@@ -326,8 +339,12 @@ class PlainCensus extends Census {
 }
 
 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();
   }
   /**
@@ -419,7 +436,7 @@ class WeightedCensus extends Census {
 
 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");
     }
@@ -443,8 +460,16 @@ class CspCensus extends Census {
 }
 
 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;
@@ -943,6 +968,8 @@ class ProcessStatusError extends ContractServiceError {
 }
 class ProcessCensusError extends ContractServiceError {
 }
+class CensusNotUpdatable extends ContractServiceError {
+}
 class ProcessDurationError extends ContractServiceError {
 }
 class ProcessStateTransitionError extends ContractServiceError {
@@ -1006,7 +1033,7 @@ class ProcessRegistryService extends SmartContractService {
     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,
@@ -1017,6 +1044,7 @@ class ProcessRegistryService extends SmartContractService {
         status,
         startTime,
         duration,
+        maxVoters,
         ballotMode,
         contractCensus,
         metadata,
@@ -1057,6 +1085,14 @@ class ProcessRegistryService extends SmartContractService {
       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)`
    */
@@ -1113,12 +1149,12 @@ class ProcessRegistryService extends SmartContractService {
       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(
@@ -1127,6 +1163,13 @@ class ProcessRegistryService extends SmartContractService {
       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();
@@ -1232,6 +1275,7 @@ class ProcessOrchestrationService {
       endDate: new Date(endTime * 1e3),
       duration,
       timeRemaining,
+      maxVoters: Number(rawProcess.maxVoters),
       result: rawProcess.result,
       votersCount: Number(rawProcess.votersCount),
       overwrittenVotesCount: Number(rawProcess.overwrittenVotesCount),
@@ -1286,6 +1330,7 @@ class ProcessOrchestrationService {
       ProcessStatus.READY,
       data.startTime,
       data.duration,
+      data.maxVoters,
       data.ballotMode,
       data.census,
       data.metadataUri,
@@ -1373,6 +1418,7 @@ class ProcessOrchestrationService {
       ballotMode,
       signature
     });
+    const maxVoters = config.maxVoters ?? censusConfig.size;
     const census = {
       censusOrigin: censusConfig.type,
       censusRoot,
@@ -1382,6 +1428,7 @@ class ProcessOrchestrationService {
       processId,
       startTime,
       duration,
+      maxVoters,
       censusRoot,
       ballotMode,
       metadataUri,
@@ -1768,6 +1815,84 @@ class ProcessOrchestrationService {
     }
     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 {
@@ -1923,7 +2048,7 @@ class VoteOrchestrationService {
       signature,
       voteId
     };
-    if (process.census.censusOrigin === CensusOrigin.CensusOriginCSP) {
+    if (process.census.censusOrigin === CensusOrigin.CSP) {
       voteRequest.censusProof = censusProof;
     }
     await this.submitVoteRequest(voteRequest);
@@ -2039,7 +2164,7 @@ class VoteOrchestrationService {
    * 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,
@@ -2053,13 +2178,13 @@ class VoteOrchestrationService {
           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 })."
@@ -2633,7 +2758,7 @@ class DavinciSDK {
    *   title: "My Election",
    *   description: "A simple election",
    *   census: {
-   *     type: CensusOrigin.CensusOriginMerkleTree,
+   *     type: CensusOrigin.OffchainStatic,
    *     root: "0x1234...",
    *     size: 100,
    *     uri: "ipfs://..."
@@ -2720,7 +2845,7 @@ class DavinciSDK {
    *   title: "My Election",
    *   description: "A simple election",
    *   census: {
-   *     type: CensusOrigin.CensusOriginMerkleTree,
+   *     type: CensusOrigin.OffchainStatic,
    *     root: "0x1234...",
    *     size: 100,
    *     uri: "ipfs://your-census-uri"
@@ -3272,6 +3397,77 @@ class DavinciSDK {
     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)
@@ -3348,6 +3544,7 @@ class DavinciSDK {
 
 exports.BaseService = BaseService;
 exports.Census = Census;
+exports.CensusNotUpdatable = CensusNotUpdatable;
 exports.CensusOrchestrator = CensusOrchestrator;
 exports.CensusOrigin = CensusOrigin;
 exports.CensusType = CensusType;