@vocdoni/davinci-sdk 0.0.7 → 0.1.1

package/dist/index.umd.js

@@ -219,34 +219,12 @@
     }
   }
 
-  var CensusType = /* @__PURE__ */ ((CensusType2) => {
-    CensusType2["PLAIN"] = "plain";
-    CensusType2["WEIGHTED"] = "weighted";
-    CensusType2["CSP"] = "csp";
-    return CensusType2;
-  })(CensusType || {});
   class Census {
-    constructor(type, censusOrigin) {
+    constructor(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}`);
-        }
-      }
+      this._censusOrigin = censusOrigin;
     }
     get censusId() {
       return this._censusId;
@@ -257,12 +235,6 @@
     get censusURI() {
       return this._censusURI;
     }
-    get type() {
-      return this._type;
-    }
-    get size() {
-      return this._size;
-    }
     get isPublished() {
       return this._censusRoot !== null && this._censusURI !== null;
     }
@@ -272,91 +244,41 @@
     get censusOrigin() {
       return this._censusOrigin;
     }
-  }
-
-  class PlainCensus extends Census {
-    /**
-     * 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();
-    }
     /**
-     * Add participant(s) with automatic weight=1
-     * @param addresses - Single address or array of addresses
+     * 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
      */
-    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
-      }));
-    }
-    /**
-     * Get addresses only
-     */
-    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 {
-    /**
-     * Creates a new WeightedCensus
-     * @param censusOrigin - The census origin (defaults to OffchainStatic for backward compatibility)
-     */
+  class MerkleCensus extends Census {
     constructor(censusOrigin) {
-      super(CensusType.WEIGHTED, 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);
       }
     }
     /**
@@ -386,6 +308,21 @@
     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
      */
@@ -410,32 +347,66 @@
       }
       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 - The URI pointing to census data source (e.g., subgraph endpoint)
+     */
+    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");
+      }
+      if (!uri || uri.trim() === "") {
+        throw new Error("URI is required for onchain census");
+      }
+      this._contractAddress = contractAddress;
+      this._censusRoot = "0x0000000000000000000000000000000000000000000000000000000000000000";
+      this._censusURI = uri;
+    }
+    get contractAddress() {
+      return this._contractAddress;
+    }
+  }
+
   class CspCensus extends Census {
-    constructor(publicKey, cspURI, size) {
-      super(CensusType.CSP, CensusOrigin.CSP);
+    constructor(publicKey, cspURI) {
+      super(CensusOrigin.CSP);
       if (!/^(0x)?[0-9a-fA-F]+$/.test(publicKey)) {
         throw new Error("Public key is missing or invalid");
       }
@@ -448,7 +419,6 @@
       this._cspURI = cspURI;
       this._censusRoot = publicKey;
       this._censusURI = cspURI;
-      this._size = size;
     }
     get publicKey() {
       return this._publicKey;
@@ -461,17 +431,14 @@
   class PublishedCensus extends Census {
     /**
      * Creates a PublishedCensus from existing census data
-     * @param type - The census type (PLAIN, WEIGHTED, or CSP)
+     * @param censusOrigin - The census origin (OffchainStatic, OffchainDynamic, Onchain, 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);
+    constructor(censusOrigin, root, uri) {
+      super(censusOrigin);
       this._censusRoot = root;
       this._censusURI = uri;
-      this._size = size;
     }
   }
 
@@ -480,7 +447,7 @@
       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) {
@@ -496,23 +463,26 @@
       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");
+      }
+      const contractAddress = "contractAddress" in census ? census.contractAddress : void 0;
       return {
         type: census.censusOrigin,
         root: census.censusRoot,
         uri: census.censusURI,
-        size: census.size
+        contractAddress
       };
     }
   }
@@ -1036,7 +1006,9 @@
       const contractCensus = {
         censusOrigin: BigInt(census.censusOrigin),
         censusRoot: census.censusRoot,
-        censusURI: census.censusURI
+        contractAddress: census.contractAddress ?? "0x0000000000000000000000000000000000000000",
+        censusURI: census.censusURI,
+        onchainAllowAnyValidRoot: census.onchainAllowAnyValidRoot ?? false
       };
       return this.sendTx(
         this.contract.newProcess(
@@ -1067,7 +1039,9 @@
       const contractCensus = {
         censusOrigin: BigInt(census.censusOrigin),
         censusRoot: census.censusRoot,
-        censusURI: census.censusURI
+        contractAddress: census.contractAddress ?? "0x0000000000000000000000000000000000000000",
+        censusURI: census.censusURI,
+        onchainAllowAnyValidRoot: census.onchainAllowAnyValidRoot ?? false
       };
       return this.sendTx(
         this.contract.setProcessCensus(processID, contractCensus).catch((e) => {
@@ -1190,26 +1164,19 @@
      */
     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 this.censusOrchestrator.getCensusData(census);
       }
-      return census;
+      const { size, ...censusWithoutSize } = census;
+      return censusWithoutSize;
     }
     /**
      * Gets user-friendly process information by transforming raw contract data
@@ -1417,11 +1384,31 @@
         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,
-        censusURI: censusConfig.uri
+        contractAddress: censusConfig.contractAddress,
+        // Only set for onchain censuses
+        censusURI: censusConfig.uri,
+        // For onchain censuses (ERC20 token snapshots), allow any valid merkle root
+        // For other census types, require the specific censusRoot
+        onchainAllowAnyValidRoot: censusConfig.type === CensusOrigin.Onchain
       };
       return {
         processId,
@@ -3546,7 +3533,6 @@
   exports.CensusNotUpdatable = CensusNotUpdatable;
   exports.CensusOrchestrator = CensusOrchestrator;
   exports.CensusOrigin = CensusOrigin;
-  exports.CensusType = CensusType;
   exports.CircomProof = CircomProof;
   exports.ContractServiceError = ContractServiceError;
   exports.CspCensus = CspCensus;
@@ -3554,12 +3540,15 @@
   exports.DavinciSDK = DavinciSDK;
   exports.ElectionMetadataTemplate = ElectionMetadataTemplate;
   exports.ElectionResultsTypeNames = ElectionResultsTypeNames;
+  exports.MerkleCensus = MerkleCensus;
+  exports.OffchainCensus = OffchainCensus;
+  exports.OffchainDynamicCensus = OffchainDynamicCensus;
+  exports.OnchainCensus = OnchainCensus;
   exports.OrganizationAdministratorError = OrganizationAdministratorError;
   exports.OrganizationCreateError = OrganizationCreateError;
   exports.OrganizationDeleteError = OrganizationDeleteError;
   exports.OrganizationRegistryService = OrganizationRegistryService;
   exports.OrganizationUpdateError = OrganizationUpdateError;
-  exports.PlainCensus = PlainCensus;
   exports.ProcessCensusError = ProcessCensusError;
   exports.ProcessCreateError = ProcessCreateError;
   exports.ProcessDurationError = ProcessDurationError;
@@ -3577,7 +3566,6 @@
   exports.VocdoniSequencerService = VocdoniSequencerService;
   exports.VoteOrchestrationService = VoteOrchestrationService;
   exports.VoteStatus = VoteStatus;
-  exports.WeightedCensus = WeightedCensus;
   exports.assertCSPCensusProof = assertCSPCensusProof;
   exports.assertMerkleCensusProof = assertMerkleCensusProof;
   exports.createProcessSignatureMessage = createProcessSignatureMessage;

package/dist/sequencer.d.ts

@@ -149,7 +149,19 @@ interface BallotMode {
 interface CensusData {
     censusOrigin: CensusOrigin;
     censusRoot: string;
+    /**
+     * Contract address for onchain censuses (ERC20/ERC721 token contract).
+     * For offchain censuses, defaults to zero address.
+     * @default "0x0000000000000000000000000000000000000000"
+     */
+    contractAddress?: string;
     censusURI: string;
+    /**
+     * For onchain censuses, allows any valid Merkle root from the onchain source.
+     * For other census types, set to false to require the specific censusRoot.
+     * @default false
+     */
+    onchainAllowAnyValidRoot?: boolean;
 }
 interface EncryptionKey {
     x: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vocdoni/davinci-sdk",
-  "version": "0.0.7",
+  "version": "0.1.1",
   "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.31",
+    "@vocdoni/davinci-contracts": "0.0.35",
     "axios": "^1.8.4",
     "ethers": "^6.7.1",
     "snarkjs": "^0.7.5"