@vocdoni/davinci-sdk 0.0.4 → 0.0.6

package/dist/index.umd.js

@@ -564,11 +564,26 @@
         throw error;
       }
     }
-    isAddressAbleToVote(processId, address) {
-      return this.request({
+    async getAddressWeight(processId, address) {
+      const participant = await this.request({
         method: "GET",
         url: `/processes/${processId}/participants/${address}`
       });
+      return participant.weight;
+    }
+    async isAddressAbleToVote(processId, address) {
+      try {
+        await this.request({
+          method: "GET",
+          url: `/processes/${processId}/participants/${address}`
+        });
+        return true;
+      } catch (error) {
+        if (error?.code === 40001) {
+          return false;
+        }
+        throw error;
+      }
     }
     getInfo() {
       return this.request({
@@ -990,7 +1005,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,
@@ -1001,6 +1016,7 @@
           status,
           startTime,
           duration,
+          maxVoters,
           ballotMode,
           contractCensus,
           metadata,
@@ -1041,6 +1057,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)`
      */
@@ -1111,6 +1135,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();
@@ -1216,9 +1247,10 @@
         endDate: new Date(endTime * 1e3),
         duration,
         timeRemaining,
+        maxVoters: Number(rawProcess.maxVoters),
         result: rawProcess.result,
-        voteCount: Number(rawProcess.voteCount),
-        voteOverwriteCount: Number(rawProcess.voteOverwriteCount),
+        votersCount: Number(rawProcess.votersCount),
+        overwrittenVotesCount: Number(rawProcess.overwrittenVotesCount),
         metadataURI: rawProcess.metadataURI,
         raw: rawProcess
       };
@@ -1270,6 +1302,7 @@
         ProcessStatus.READY,
         data.startTime,
         data.duration,
+        data.maxVoters,
         data.ballotMode,
         data.census,
         data.metadataUri,
@@ -1357,6 +1390,7 @@
         ballotMode,
         signature
       });
+      const maxVoters = config.maxVoters ?? censusConfig.size;
       const census = {
         censusOrigin: censusConfig.type,
         censusRoot,
@@ -1366,6 +1400,7 @@
         processId,
         startTime,
         duration,
+        maxVoters,
         censusRoot,
         ballotMode,
         metadataUri,
@@ -1752,6 +1787,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 {
@@ -2032,9 +2145,15 @@
           assertMerkleCensusProof(proof);
           return proof;
         } else {
-          const proof = await this.apiService.census.getCensusProof(censusRoot, voterAddress);
-          assertMerkleCensusProof(proof);
-          return proof;
+          const weight = await this.apiService.sequencer.getAddressWeight(processId, voterAddress);
+          return {
+            root: censusRoot,
+            address: voterAddress,
+            weight,
+            censusOrigin: CensusOrigin.CensusOriginMerkleTree,
+            value: "",
+            siblings: ""
+          };
         }
       }
       if (censusOrigin === CensusOrigin.CensusOriginCSP) {
@@ -2844,29 +2963,55 @@
       return this.voteOrchestrator.hasAddressVoted(processId, address);
     }
     /**
-     * Check if an address is able to vote in a process and get participant information.
+     * Check if an address is able to vote in a process (i.e., is in the census).
      *
      * Does NOT require a provider - uses API calls only.
      *
      * @param processId - The process ID
      * @param address - The voter's address
-     * @returns Promise resolving to participant information (key and weight)
+     * @returns Promise resolving to boolean indicating if the address can vote
      *
      * @example
      * ```typescript
-     * const participantInfo = await sdk.isAddressAbleToVote(processId, "0x1234567890abcdef...");
-     * console.log("Address:", participantInfo.key);
-     * console.log("Weight:", participantInfo.weight);
+     * const canVote = await sdk.isAddressAbleToVote(processId, "0x1234567890abcdef...");
+     * if (canVote) {
+     *   console.log("This address can vote");
+     * } else {
+     *   console.log("This address is not in the census");
+     * }
      * ```
      */
     async isAddressAbleToVote(processId, address) {
       if (!this.initialized) {
         throw new Error(
-          "SDK must be initialized before checking participant info. Call sdk.init() first."
+          "SDK must be initialized before checking if address can vote. Call sdk.init() first."
         );
       }
       return this.apiService.sequencer.isAddressAbleToVote(processId, address);
     }
+    /**
+     * Get the voting weight for an address in a process.
+     *
+     * Does NOT require a provider - uses API calls only.
+     *
+     * @param processId - The process ID
+     * @param address - The voter's address
+     * @returns Promise resolving to the address weight as a string
+     *
+     * @example
+     * ```typescript
+     * const weight = await sdk.getAddressWeight(processId, "0x1234567890abcdef...");
+     * console.log("Address weight:", weight);
+     * ```
+     */
+    async getAddressWeight(processId, address) {
+      if (!this.initialized) {
+        throw new Error(
+          "SDK must be initialized before getting address weight. Call sdk.init() first."
+        );
+      }
+      return this.apiService.sequencer.getAddressWeight(processId, address);
+    }
     /**
      * Watch vote status changes in real-time using an async generator.
      * This method yields each status change as it happens, perfect for showing
@@ -3224,6 +3369,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)

package/dist/sequencer.d.ts

@@ -174,36 +174,14 @@ interface GetProcessResponse {
     organizationId: string;
     encryptionKey: EncryptionKey;
     stateRoot: string;
-    result: string[];
-    startTime: number;
+    result: string[] | null;
+    startTime: string;
     duration: number;
     metadataURI: string;
     ballotMode: BallotMode;
     census: CensusData;
-    metadata: {
-        title: Record<string, string>;
-        description: Record<string, string>;
-        media: {
-            header: string;
-            logo: string;
-        };
-        questions: {
-            title: Record<string, string>;
-            description: Record<string, string>;
-            choices: {
-                title: Record<string, string>;
-                value: number;
-                meta: Record<string, string>;
-            }[];
-            meta: Record<string, string>;
-        }[];
-        processType: {
-            name: string;
-            properties: Record<string, string>;
-        };
-    };
-    voteCount: string;
-    voteOverwrittenCount: string;
+    votersCount: string;
+    overwrittenVotesCount: string;
     isAcceptingVotes: boolean;
     sequencerStats: {
         stateTransitionCount: number;
@@ -531,7 +509,8 @@ declare class VocdoniSequencerService extends BaseService {
     submitVote(vote: VoteRequest): Promise<void>;
     getVoteStatus(processId: string, voteId: string): Promise<VoteStatusResponse>;
     hasAddressVoted(processId: string, address: string): Promise<boolean>;
-    isAddressAbleToVote(processId: string, address: string): Promise<ParticipantInfoResponse>;
+    getAddressWeight(processId: string, address: string): Promise<string>;
+    isAddressAbleToVote(processId: string, address: string): Promise<boolean>;
     getInfo(): Promise<InfoResponse>;
     pushMetadata(metadata: ElectionMetadata): Promise<string>;
     getMetadata(hashOrUrl: string): Promise<ElectionMetadata>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vocdoni/davinci-sdk",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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.26",
+    "@vocdoni/davinci-contracts": "0.0.29",
     "axios": "^1.8.4",
     "ethers": "^6.7.1",
     "snarkjs": "^0.7.5"