@vocdoni/davinci-sdk 0.0.6 → 0.1.0

package/dist/index.mjs

@@ -192,18 +192,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)) {
@@ -216,19 +218,12 @@ function assertCSPCensusProof(proof) {
   }
 }
 
-var CensusType = /* @__PURE__ */ ((CensusType2) => {
-  CensusType2["PLAIN"] = "plain";
-  CensusType2["WEIGHTED"] = "weighted";
-  CensusType2["CSP"] = "csp";
-  return CensusType2;
-})(CensusType || {});
 class Census {
-  constructor(type) {
+  constructor(censusOrigin) {
     this._censusId = null;
     this._censusRoot = null;
     this._censusURI = null;
-    this._size = null;
-    this._type = type;
+    this._censusOrigin = censusOrigin;
   }
   get censusId() {
     return this._censusId;
@@ -239,106 +234,50 @@ class Census {
   get censusURI() {
     return this._censusURI;
   }
-  get type() {
-    return this._type;
-  }
-  get size() {
-    return this._size;
-  }
   get isPublished() {
     return this._censusRoot !== null && this._censusURI !== null;
   }
   /**
-   * Convert CensusType to CensusOrigin enum for API compatibility
+   * Get 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}`);
-    }
-  }
-}
-
-class PlainCensus extends Census {
-  constructor() {
-    super(CensusType.PLAIN);
-    this._participants = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Add participant(s) with automatic weight=1
-   * @param addresses - Single address or array of addresses
-   */
-  add(addresses) {
-    const toAdd = Array.isArray(addresses) ? addresses : [addresses];
-    for (const address of toAdd) {
-      this.validateAddress(address);
-      this._participants.add(address.toLowerCase());
-    }
-  }
-  /**
-   * Remove participant by address
-   */
-  remove(address) {
-    this._participants.delete(address.toLowerCase());
-  }
-  /**
-   * Get all participants as CensusParticipant array (for API)
-   * All participants have weight="1"
-   */
-  get participants() {
-    return Array.from(this._participants).map((key) => ({
-      key,
-      weight: "1"
-      // Everyone has weight=1 in plain census
-    }));
+    return this._censusOrigin;
   }
   /**
-   * Get addresses only
+   * Check if this census requires publishing via the Census API
+   * Merkle censuses (OffchainStatic, OffchainDynamic) need to be published
+   * Onchain and CSP censuses are ready immediately upon construction
    */
-  get addresses() {
-    return Array.from(this._participants);
-  }
-  validateAddress(address) {
-    if (!address || typeof address !== "string") {
-      throw new Error("Address is required and must be a string");
-    }
-    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(address)) {
-      throw new Error(`Invalid Ethereum address format: ${address}`);
-    }
-  }
-  /**
-   * Internal method called after publishing
-   * @internal
-   */
-  _setPublishedData(root, uri, size, censusId) {
-    this._censusRoot = root;
-    this._censusURI = uri;
-    this._size = size;
-    if (censusId) this._censusId = censusId;
+  get requiresPublishing() {
+    return this._censusOrigin === CensusOrigin.OffchainStatic || this._censusOrigin === CensusOrigin.OffchainDynamic;
   }
 }
 
-class WeightedCensus extends Census {
-  constructor() {
-    super(CensusType.WEIGHTED);
+class MerkleCensus extends Census {
+  constructor(censusOrigin) {
+    super(censusOrigin);
     this._participants = /* @__PURE__ */ new Map();
   }
   /**
-   * Add participant(s) with custom weights
-   * Weight can be provided as string, number, or bigint - will be converted to string internally
-   * @param participant - Single participant or array of participants with custom weights
+   * Add participant(s) - supports both plain addresses and weighted participants
+   * @param data - Can be:
+   *   - string: single address (weight=1)
+   *   - string[]: array of addresses (weight=1 for all)
+   *   - {key: string, weight: string|number|bigint}: single weighted participant
+   *   - Array of weighted participants
    */
-  add(participant) {
-    const toAdd = Array.isArray(participant) ? participant : [participant];
-    for (const p of toAdd) {
-      this.validateParticipant(p);
-      const weightString = this.normalizeWeight(p.weight);
-      this._participants.set(p.key.toLowerCase(), weightString);
+  add(data) {
+    if (typeof data === "string") {
+      this.addAddress(data, "1");
+    } else if (Array.isArray(data)) {
+      if (data.length === 0) return;
+      if (typeof data[0] === "string") {
+        data.forEach((addr) => this.addAddress(addr, "1"));
+      } else {
+        data.forEach((p) => this.addParticipant(p));
+      }
+    } else {
+      this.addParticipant(data);
     }
   }
   /**
@@ -368,6 +307,21 @@ class WeightedCensus extends Census {
   getWeight(address) {
     return this._participants.get(address.toLowerCase());
   }
+  /**
+   * Internal method to add a plain address with a given weight
+   */
+  addAddress(address, weight) {
+    this.validateAddress(address);
+    this._participants.set(address.toLowerCase(), weight);
+  }
+  /**
+   * Internal method to add a weighted participant
+   */
+  addParticipant(participant) {
+    this.validateAddress(participant.key);
+    const weight = this.normalizeWeight(participant.weight);
+    this._participants.set(participant.key.toLowerCase(), weight);
+  }
   /**
    * Normalizes weight from string, number, or bigint to string
    */
@@ -392,32 +346,63 @@ class WeightedCensus extends Census {
     }
     throw new Error(`Invalid weight type. Must be string, number, or bigint.`);
   }
-  validateParticipant(participant) {
-    if (!participant.key || typeof participant.key !== "string") {
-      throw new Error("Participant key (address) is required");
-    }
-    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(participant.key)) {
-      throw new Error(`Invalid Ethereum address format: ${participant.key}`);
+  /**
+   * Validates Ethereum address format
+   */
+  validateAddress(address) {
+    if (!address || typeof address !== "string") {
+      throw new Error("Address is required and must be a string");
     }
-    if (participant.weight === void 0 || participant.weight === null) {
-      throw new Error("Participant weight is required");
+    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(address)) {
+      throw new Error(`Invalid Ethereum address format: ${address}`);
     }
   }
   /**
    * Internal method called after publishing
    * @internal
    */
-  _setPublishedData(root, uri, size, censusId) {
+  _setPublishedData(root, uri, censusId) {
     this._censusRoot = root;
     this._censusURI = uri;
-    this._size = size;
     if (censusId) this._censusId = censusId;
   }
 }
 
+class OffchainCensus extends MerkleCensus {
+  constructor() {
+    super(CensusOrigin.OffchainStatic);
+  }
+}
+
+class OffchainDynamicCensus extends MerkleCensus {
+  constructor() {
+    super(CensusOrigin.OffchainDynamic);
+  }
+}
+
+class OnchainCensus extends Census {
+  /**
+   * Creates an OnchainCensus
+   * @param contractAddress - The address of the smart contract (e.g., ERC20, ERC721)
+   * @param uri - Optional URI with census information
+   */
+  constructor(contractAddress, uri) {
+    super(CensusOrigin.Onchain);
+    if (!/^(0x)?[0-9a-fA-F]{40}$/i.test(contractAddress)) {
+      throw new Error("Contract address is missing or invalid");
+    }
+    this._contractAddress = contractAddress;
+    this._censusRoot = contractAddress;
+    this._censusURI = uri || `contract://${contractAddress}`;
+  }
+  get contractAddress() {
+    return this._contractAddress;
+  }
+}
+
 class CspCensus extends Census {
-  constructor(publicKey, cspURI, size) {
-    super(CensusType.CSP);
+  constructor(publicKey, cspURI) {
+    super(CensusOrigin.CSP);
     if (!/^(0x)?[0-9a-fA-F]+$/.test(publicKey)) {
       throw new Error("Public key is missing or invalid");
     }
@@ -430,7 +415,6 @@ class CspCensus extends Census {
     this._cspURI = cspURI;
     this._censusRoot = publicKey;
     this._censusURI = cspURI;
-    this._size = size;
   }
   get publicKey() {
     return this._publicKey;
@@ -441,11 +425,16 @@ class CspCensus extends Census {
 }
 
 class PublishedCensus extends Census {
-  constructor(type, root, uri, size) {
-    super(type);
+  /**
+   * Creates a PublishedCensus from existing census data
+   * @param censusOrigin - The census origin (OffchainStatic, OffchainDynamic, Onchain, or CSP)
+   * @param root - The census root
+   * @param uri - The census URI
+   */
+  constructor(censusOrigin, root, uri) {
+    super(censusOrigin);
     this._censusRoot = root;
     this._censusURI = uri;
-    this._size = size;
   }
 }
 
@@ -454,7 +443,7 @@ class CensusOrchestrator {
     this.censusService = censusService;
   }
   /**
-   * Publishes a PlainCensus or WeightedCensus
+   * Publishes a MerkleCensus (OffchainCensus, OffchainDynamicCensus, or OnchainCensus)
    * Creates a working census, adds participants, and publishes it
    */
   async publish(census) {
@@ -470,23 +459,24 @@ class CensusOrchestrator {
     census._setPublishedData(
       publishResponse.root,
       publishResponse.uri,
-      publishResponse.participantCount,
       censusId
     );
   }
   /**
    * Gets census data for process creation
-   * Throws if census is not published
+   * Throws if census is not ready (published for Merkle/CSP, or constructed for Onchain)
    */
   getCensusData(census) {
-    if (!census.isPublished) {
-      throw new Error("Census must be published before creating a process");
+    if (census.requiresPublishing && !census.isPublished) {
+      throw new Error("Merkle census must be published before creating a process");
+    }
+    if (!census.censusRoot || !census.censusURI) {
+      throw new Error("Census data is incomplete");
     }
     return {
       type: census.censusOrigin,
       root: census.censusRoot,
-      uri: census.censusURI,
-      size: census.size
+      uri: census.censusURI
     };
   }
 }
@@ -941,6 +931,8 @@ class ProcessStatusError extends ContractServiceError {
 }
 class ProcessCensusError extends ContractServiceError {
 }
+class CensusNotUpdatable extends ContractServiceError {
+}
 class ProcessDurationError extends ContractServiceError {
 }
 class ProcessStateTransitionError extends ContractServiceError {
@@ -1120,12 +1112,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(
@@ -1162,26 +1154,24 @@ class ProcessOrchestrationService {
    */
   async handleCensus(census) {
     if ("isPublished" in census) {
-      if (census instanceof PlainCensus || census instanceof WeightedCensus) {
-        if (!census.isPublished) {
-          const censusBaseURL = this.apiService.census?.["axios"]?.defaults?.baseURL;
-          if (!censusBaseURL || censusBaseURL === "" || censusBaseURL === "undefined") {
-            throw new Error(
-              'Census API URL is required to publish PlainCensus or WeightedCensus. Please provide "censusUrl" when initializing DavinciSDK, or use a pre-published census.'
-            );
-          }
-          await this.censusOrchestrator.publish(census);
+      if (census.requiresPublishing && !census.isPublished) {
+        const censusBaseURL = this.apiService.census?.["axios"]?.defaults?.baseURL;
+        if (!censusBaseURL || censusBaseURL === "" || censusBaseURL === "undefined") {
+          throw new Error(
+            'Census API URL is required to publish Merkle censuses (OffchainCensus, OffchainDynamicCensus). Please provide "censusUrl" when initializing DavinciSDK, or use a pre-published census.'
+          );
         }
+        await this.censusOrchestrator.publish(census);
       }
       const censusData = this.censusOrchestrator.getCensusData(census);
       return {
         type: censusData.type,
         root: censusData.root,
-        size: censusData.size,
         uri: censusData.uri
       };
     }
-    return census;
+    const { size, ...censusWithoutSize } = census;
+    return censusWithoutSize;
   }
   /**
    * Gets user-friendly process information by transforming raw contract data
@@ -1389,7 +1379,22 @@ class ProcessOrchestrationService {
       ballotMode,
       signature
     });
-    const maxVoters = config.maxVoters ?? censusConfig.size;
+    let maxVoters;
+    if (config.maxVoters !== void 0) {
+      maxVoters = config.maxVoters;
+    } else if ("isPublished" in config.census && config.census.isPublished) {
+      if ("participants" in config.census) {
+        maxVoters = config.census.participants.length;
+      } else {
+        throw new Error(
+          "maxVoters is required when using OnchainCensus, CspCensus, or PublishedCensus. It can only be auto-calculated for published MerkleCensus (OffchainCensus/OffchainDynamicCensus)."
+        );
+      }
+    } else {
+      throw new Error(
+        "maxVoters is required. It can only be omitted when using a published MerkleCensus (OffchainCensus/OffchainDynamicCensus), in which case it defaults to the participant count."
+      );
+    }
     const census = {
       censusOrigin: censusConfig.type,
       censusRoot,
@@ -2019,7 +2024,7 @@ class VoteOrchestrationService {
       signature,
       voteId
     };
-    if (process.census.censusOrigin === CensusOrigin.CensusOriginCSP) {
+    if (process.census.censusOrigin === CensusOrigin.CSP) {
       voteRequest.censusProof = censusProof;
     }
     await this.submitVoteRequest(voteRequest);
@@ -2135,7 +2140,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,
@@ -2149,13 +2154,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 })."
@@ -2729,7 +2734,7 @@ class DavinciSDK {
    *   title: "My Election",
    *   description: "A simple election",
    *   census: {
-   *     type: CensusOrigin.CensusOriginMerkleTree,
+   *     type: CensusOrigin.OffchainStatic,
    *     root: "0x1234...",
    *     size: 100,
    *     uri: "ipfs://..."
@@ -2816,7 +2821,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"
@@ -3513,5 +3518,5 @@ class DavinciSDK {
   }
 }
 
-export { BaseService, Census, CensusOrchestrator, CensusOrigin, CensusType, CircomProof, ContractServiceError, CspCensus, DavinciCrypto, DavinciSDK, ElectionMetadataTemplate, ElectionResultsTypeNames, OrganizationAdministratorError, OrganizationCreateError, OrganizationDeleteError, OrganizationRegistryService, OrganizationUpdateError, PlainCensus, ProcessCensusError, ProcessCreateError, ProcessDurationError, ProcessOrchestrationService, ProcessRegistryService, ProcessResultError, ProcessStateTransitionError, ProcessStatus, ProcessStatusError, PublishedCensus, SmartContractService, TxStatus, VocdoniApiService, VocdoniCensusService, VocdoniSequencerService, VoteOrchestrationService, VoteStatus, WeightedCensus, assertCSPCensusProof, assertMerkleCensusProof, createProcessSignatureMessage, getElectionMetadataTemplate, isCSPCensusProof, isMerkleCensusProof, signProcessCreation, validateProcessId };
+export { BaseService, Census, CensusNotUpdatable, CensusOrchestrator, CensusOrigin, CircomProof, ContractServiceError, CspCensus, DavinciCrypto, DavinciSDK, ElectionMetadataTemplate, ElectionResultsTypeNames, MerkleCensus, OffchainCensus, OffchainDynamicCensus, OnchainCensus, OrganizationAdministratorError, OrganizationCreateError, OrganizationDeleteError, OrganizationRegistryService, OrganizationUpdateError, ProcessCensusError, ProcessCreateError, ProcessDurationError, ProcessOrchestrationService, ProcessRegistryService, ProcessResultError, ProcessStateTransitionError, ProcessStatus, ProcessStatusError, PublishedCensus, SmartContractService, TxStatus, VocdoniApiService, VocdoniCensusService, VocdoniSequencerService, VoteOrchestrationService, VoteStatus, assertCSPCensusProof, assertMerkleCensusProof, createProcessSignatureMessage, getElectionMetadataTemplate, isCSPCensusProof, isMerkleCensusProof, signProcessCreation, validateProcessId };
 //# sourceMappingURL=index.mjs.map