@maci-protocol/contracts 0.0.0-ci.26f28d6

package/build/typechain-types/solady/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/build/typechain-types/solady/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../typechain-types/solady/index.ts"],"names":[],"mappings":""}

package/build/typechain-types/solady/src/index.d.ts

@@ -0,0 +1,3 @@
+import type * as utils from "./utils";
+export type { utils };
+//# sourceMappingURL=index.d.ts.map

package/build/typechain-types/solady/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../typechain-types/solady/src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,KAAK,MAAM,SAAS,CAAC;AACtC,YAAY,EAAE,KAAK,EAAE,CAAC"}

package/build/typechain-types/solady/src/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/build/typechain-types/solady/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../typechain-types/solady/src/index.ts"],"names":[],"mappings":""}

package/build/typechain-types/solady/src/utils/LibClone.d.ts

@@ -0,0 +1,21 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
+export interface LibCloneInterface extends Interface {
+}
+export interface LibClone extends BaseContract {
+    connect(runner?: ContractRunner | null): LibClone;
+    waitForDeployment(): Promise<this>;
+    interface: LibCloneInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}
+//# sourceMappingURL=LibClone.d.ts.map

package/build/typechain-types/solady/src/utils/LibClone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibClone.d.ts","sourceRoot":"","sources":["../../../../../typechain-types/solady/src/utils/LibClone.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,cAAc,EACd,cAAc,EACd,QAAQ,EACT,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,aAAa,EACb,aAAa,EACd,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,iBAAkB,SAAQ,SAAS;CAAG;AAEvD,MAAM,WAAW,QAAS,SAAQ,YAAY;IAC5C,OAAO,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,GAAG,QAAQ,CAAC;IAClD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC,SAAS,EAAE,iBAAiB,CAAC;IAE7B,WAAW,CAAC,OAAO,SAAS,kBAAkB,EAC5C,KAAK,EAAE,OAAO,EACd,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClD,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GACpC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1C,WAAW,CAAC,OAAO,SAAS,kBAAkB,EAC5C,MAAM,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACzC,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClD,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GACpC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE1C,EAAE,CAAC,OAAO,SAAS,kBAAkB,EACnC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,EAAE,CAAC,OAAO,SAAS,kBAAkB,EACnC,MAAM,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,IAAI,CAAC,OAAO,SAAS,kBAAkB,EACrC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,IAAI,CAAC,OAAO,SAAS,kBAAkB,EACrC,MAAM,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,SAAS,CAAC,OAAO,SAAS,kBAAkB,EAC1C,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1C,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxD,kBAAkB,CAAC,OAAO,SAAS,kBAAkB,EACnD,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,WAAW,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EACnD,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAC7B,CAAC,CAAC;IAEL,OAAO,EAAE,EAAE,CAAC;CACb"}

package/build/typechain-types/solady/src/utils/LibClone.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=LibClone.js.map

package/build/typechain-types/solady/src/utils/LibClone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibClone.js","sourceRoot":"","sources":["../../../../../typechain-types/solady/src/utils/LibClone.ts"],"names":[],"mappings":""}

package/build/typechain-types/solady/src/utils/index.d.ts

@@ -0,0 +1,2 @@
+export type { LibClone } from "./LibClone";
+//# sourceMappingURL=index.d.ts.map

package/build/typechain-types/solady/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../typechain-types/solady/src/utils/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/build/typechain-types/solady/src/utils/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/build/typechain-types/solady/src/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../typechain-types/solady/src/utils/index.ts"],"names":[],"mappings":""}

package/contracts/.solhint.json

@@ -0,0 +1,19 @@
+{
+  "extends": "solhint:recommended",
+  "rules": {
+    "indent": ["error", 4],
+    "bracket-align": "off",
+    "reason-string": [
+      "warn",
+      {
+        "maxLength": 128
+      }
+    ],
+    "separate-by-one-line-in-contract": "warn",
+    "no-empty-blocks": "off",
+    "compiler-fixed": "off",
+    "not-rely-on-time": "off",
+    "mark-callable-contracts": "off",
+    "compiler-version": ["error", "^0.8.10"]
+  }
+}

package/contracts/MACI.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { IBasePolicy } from "@excubiae/contracts/contracts/interfaces/IBasePolicy.sol";
+
+import { IPollFactory } from "./interfaces/IPollFactory.sol";
+import { IMessageProcessorFactory } from "./interfaces/IMPFactory.sol";
+import { ITallyFactory } from "./interfaces/ITallyFactory.sol";
+import { IVerifier } from "./interfaces/IVerifier.sol";
+import { IVkRegistry } from "./interfaces/IVkRegistry.sol";
+import { IInitialVoiceCreditProxy } from "./interfaces/IInitialVoiceCreditProxy.sol";
+import { IMACI } from "./interfaces/IMACI.sol";
+import { Params } from "./utilities/Params.sol";
+import { DomainObjs } from "./utilities/DomainObjs.sol";
+import { CurveBabyJubJub } from "./crypto/BabyJubJub.sol";
+import { Hasher } from "./crypto/Hasher.sol";
+import { InternalLeanIMT, LeanIMTData } from "./trees/LeanIMT.sol";
+
+/// @title MACI - Minimum Anti-Collusion Infrastructure Version 1
+/// @notice A contract which allows users to sign up, and deploy new polls
+contract MACI is IMACI, DomainObjs, Params, Hasher {
+  /// @notice The state tree depth is fixed. As such it should be as large as feasible
+  /// so that there can be as many users as possible.  i.e. 2 ** 23 = 8388608
+  /// this should also match the parameter of the circom circuits.
+  /// @notice IMPORTANT: remember to change the ballot tree depth
+  /// in contracts/ts/genEmptyBallotRootsContract.ts file
+  /// if we change the state tree depth!
+  uint8 public immutable stateTreeDepth;
+
+  uint256 public immutable maxSignups;
+
+  uint8 internal constant STATE_TREE_ARITY = 2;
+
+  /// @notice This is the poseidon hash of the pad key
+  uint256 internal constant PAD_KEY_HASH = 1309255631273308531193241901289907343161346846555918942743921933037802809814;
+
+  /// @notice The roots of the empty ballot trees
+  uint256[5] public emptyBallotRoots;
+
+  /// @notice Each poll has an incrementing ID
+  uint256 public nextPollId;
+
+  /// @notice A mapping of poll IDs to Poll contracts.
+  mapping(uint256 => PollContracts) public polls;
+
+  /// @notice Factory contract that deploy a Poll contract
+  IPollFactory public immutable pollFactory;
+
+  /// @notice Factory contract that deploy a MessageProcessor contract
+  IMessageProcessorFactory public immutable messageProcessorFactory;
+
+  /// @notice Factory contract that deploy a Tally contract
+  ITallyFactory public immutable tallyFactory;
+
+  /// @notice The state tree. Stores users' public keys
+  LeanIMTData public leanIMTData;
+
+  /// @notice Address of the signup policy, a contract which determines whether a
+  /// user may sign up to vote
+  IBasePolicy public immutable signUpPolicy;
+
+  /// @notice The array of the state tree roots for each sign up
+  /// For the N'th sign up, the state tree root will be stored at the index N
+  uint256[] public stateRootsOnSignUp;
+
+  // Events
+  event SignUp(uint256 _stateIndex, uint256 _timestamp, uint256 indexed _userPubKeyX, uint256 indexed _userPubKeyY);
+  event DeployPoll(
+    uint256 _pollId,
+    uint256 indexed _coordinatorPubKeyX,
+    uint256 indexed _coordinatorPubKeyY,
+    Mode _mode
+  );
+
+  /// @notice custom errors
+  error PoseidonHashLibrariesNotLinked();
+  error TooManySignups();
+  error InvalidPubKey();
+  error PollDoesNotExist(uint256 pollId);
+  error UserNotSignedUp();
+
+  /// @notice Create a new instance of the MACI contract.
+  /// @param _pollFactory The PollFactory contract
+  /// @param _messageProcessorFactory The MessageProcessorFactory contract
+  /// @param _tallyFactory The TallyFactory contract
+  /// @param _signUpPolicy The signup policy contract
+  /// @param _stateTreeDepth The depth of the state tree
+  /// @param _emptyBallotRoots The roots of the empty ballot trees
+  constructor(
+    IPollFactory _pollFactory,
+    IMessageProcessorFactory _messageProcessorFactory,
+    ITallyFactory _tallyFactory,
+    IBasePolicy _signUpPolicy,
+    uint8 _stateTreeDepth,
+    uint256[5] memory _emptyBallotRoots
+  ) payable {
+    // initialize and insert the blank leaf
+    InternalLeanIMT._insert(leanIMTData, PAD_KEY_HASH);
+    stateRootsOnSignUp.push(PAD_KEY_HASH);
+
+    pollFactory = _pollFactory;
+    messageProcessorFactory = _messageProcessorFactory;
+    tallyFactory = _tallyFactory;
+    signUpPolicy = _signUpPolicy;
+    stateTreeDepth = _stateTreeDepth;
+    maxSignups = uint256(STATE_TREE_ARITY) ** uint256(_stateTreeDepth);
+    emptyBallotRoots = _emptyBallotRoots;
+
+    // Verify linked poseidon libraries
+    if (hash2([uint256(1), uint256(1)]) == 0) revert PoseidonHashLibrariesNotLinked();
+  }
+
+  /// @inheritdoc IMACI
+  function signUp(PubKey memory _pubKey, bytes memory _signUpPolicyData) public virtual {
+    // ensure we do not have more signups than what the circuits support
+    if (leanIMTData.size >= maxSignups) revert TooManySignups();
+
+    // ensure that the public key is on the baby jubjub curve
+    if (!CurveBabyJubJub.isOnCurve(_pubKey.x, _pubKey.y)) {
+      revert InvalidPubKey();
+    }
+
+    // Register the user via the sign-up policy. This function should
+    // throw if the user has already registered or if ineligible to do so.
+    signUpPolicy.enforce(msg.sender, _signUpPolicyData);
+
+    // Hash the public key and insert it into the tree.
+    uint256 pubKeyHash = hashLeftRight(_pubKey.x, _pubKey.y);
+    uint256 stateRoot = InternalLeanIMT._insert(leanIMTData, pubKeyHash);
+
+    // Store the current state tree root in the array
+    stateRootsOnSignUp.push(stateRoot);
+
+    emit SignUp(leanIMTData.size - 1, block.timestamp, _pubKey.x, _pubKey.y);
+  }
+
+  /// @inheritdoc IMACI
+  function deployPoll(DeployPollArgs memory args) public virtual returns (PollContracts memory) {
+    // cache the poll to a local variable so we can increment it
+    uint256 pollId = nextPollId;
+
+    // Increment the poll ID for the next poll
+    // 2 ** 256 polls available
+    unchecked {
+      nextPollId++;
+    }
+
+    // check coordinator key is a valid point on the curve
+    if (!CurveBabyJubJub.isOnCurve(args.coordinatorPubKey.x, args.coordinatorPubKey.y)) {
+      revert InvalidPubKey();
+    }
+
+    ExtContracts memory extContracts = ExtContracts({
+      maci: IMACI(address(this)),
+      verifier: IVerifier(args.verifier),
+      vkRegistry: IVkRegistry(args.vkRegistry),
+      policy: IBasePolicy(args.policy),
+      initialVoiceCreditProxy: IInitialVoiceCreditProxy(args.initialVoiceCreditProxy)
+    });
+
+    IPollFactory.DeployPollArgs memory deployPollArgs = IPollFactory.DeployPollArgs({
+      startDate: args.startDate,
+      endDate: args.endDate,
+      treeDepths: args.treeDepths,
+      messageBatchSize: args.messageBatchSize,
+      coordinatorPubKey: args.coordinatorPubKey,
+      extContracts: extContracts,
+      emptyBallotRoot: emptyBallotRoots[args.treeDepths.voteOptionTreeDepth - 1],
+      pollId: pollId,
+      relayers: args.relayers,
+      voteOptions: args.voteOptions
+    });
+
+    address p = pollFactory.deploy(deployPollArgs);
+    address mp = messageProcessorFactory.deploy(args.verifier, args.vkRegistry, p, args.mode);
+    address tally = tallyFactory.deploy(args.verifier, args.vkRegistry, p, mp, args.mode);
+
+    // store the addresses in a struct so they can be returned
+    PollContracts memory pollAddr = PollContracts({ poll: p, messageProcessor: mp, tally: tally });
+
+    polls[pollId] = pollAddr;
+
+    emit DeployPoll(pollId, args.coordinatorPubKey.x, args.coordinatorPubKey.y, args.mode);
+
+    return pollAddr;
+  }
+
+  /// @inheritdoc IMACI
+  function getStateTreeRoot() public view returns (uint256 root) {
+    root = InternalLeanIMT._root(leanIMTData);
+  }
+
+  /// @notice Get the Poll details
+  /// @param _pollId The identifier of the Poll to retrieve
+  /// @return pollContracts The Poll contract object
+  function getPoll(uint256 _pollId) public view returns (PollContracts memory pollContracts) {
+    if (_pollId >= nextPollId) revert PollDoesNotExist(_pollId);
+    pollContracts = polls[_pollId];
+  }
+
+  /// @inheritdoc IMACI
+  function numSignUps() public view returns (uint256 signUps) {
+    signUps = leanIMTData.size;
+  }
+
+  /// @inheritdoc IMACI
+  function getStateRootOnIndexedSignUp(uint256 _index) external view returns (uint256 stateRoot) {
+    stateRoot = stateRootsOnSignUp[_index];
+  }
+
+  /// @inheritdoc IMACI
+  function getStateIndex(uint256 _pubKeyHash) external view returns (uint256) {
+    uint256 index = leanIMTData.leaves[_pubKeyHash];
+
+    if (index == 0) revert UserNotSignedUp();
+
+    // need to subtract 1 because the index is 1 indexed due to 0 index reserved for deleted leaves
+    return index - 1;
+  }
+}

package/contracts/MessageProcessor.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { IMACI } from "./interfaces/IMACI.sol";
+import { IPoll } from "./interfaces/IPoll.sol";
+import { SnarkCommon } from "./crypto/SnarkCommon.sol";
+import { Hasher } from "./crypto/Hasher.sol";
+import { IVerifier } from "./interfaces/IVerifier.sol";
+import { IVkRegistry } from "./interfaces/IVkRegistry.sol";
+import { IMessageProcessor } from "./interfaces/IMessageProcessor.sol";
+import { DomainObjs } from "./utilities/DomainObjs.sol";
+
+/// @title MessageProcessor
+/// @dev MessageProcessor is used to process messages published by signup users.
+/// It will process message by batch due to large size of messages.
+/// After it finishes processing, the sbCommitment will be used for Tally and Subsidy contracts.
+contract MessageProcessor is SnarkCommon, Hasher, IMessageProcessor, DomainObjs {
+  /// @notice custom errors
+  error NoMoreMessages();
+  error StateNotMerged();
+  error InvalidProcessMessageProof();
+  error NumSignUpsTooLarge();
+  error CurrentMessageBatchIndexTooLarge();
+  error BatchEndIndexTooLarge();
+
+  /// @inheritdoc IMessageProcessor
+  bool public processingComplete;
+
+  /// @notice  The number of batches processed
+  uint256 public numBatchesProcessed;
+
+  /// @notice The current message batch index
+  uint256 public currentBatchIndex;
+
+  /// @inheritdoc IMessageProcessor
+  uint256 public sbCommitment;
+
+  IPoll public immutable poll;
+  IVerifier public immutable verifier;
+  IVkRegistry public immutable vkRegistry;
+  Mode public immutable mode;
+
+  /// @notice Create a new instance
+  /// @param _verifier The Verifier contract address
+  /// @param _vkRegistry The VkRegistry contract address
+  /// @param _poll The Poll contract address
+  /// @param _mode Voting mode
+  constructor(address _verifier, address _vkRegistry, address _poll, Mode _mode) payable {
+    verifier = IVerifier(_verifier);
+    vkRegistry = IVkRegistry(_vkRegistry);
+    poll = IPoll(_poll);
+    mode = _mode;
+    currentBatchIndex = 1;
+  }
+
+  /// @notice Update the Poll's currentSbCommitment if the proof is valid.
+  /// @param _newSbCommitment The new state root and ballot root commitment
+  ///                         after all messages are processed
+  /// @param _proof The zk-SNARK proof
+  function processMessages(uint256 _newSbCommitment, uint256[8] calldata _proof) external {
+    // There must be unprocessed messages
+    if (processingComplete) {
+      revert NoMoreMessages();
+    }
+
+    (, uint8 voteOptionTreeDepth) = poll.treeDepths();
+    uint8 messageBatchSize = poll.messageBatchSize();
+
+    uint256[] memory batchHashes;
+    // Copy the state and ballot commitment and set the batch index if this
+    // is the first batch to process
+    if (numBatchesProcessed == 0) {
+      uint256 currentSbCommitment = poll.currentSbCommitment();
+      sbCommitment = currentSbCommitment;
+
+      /// @notice this also checks that the voting period is over so we do not
+      /// need to check it in this function
+      poll.padLastBatch();
+      batchHashes = poll.getBatchHashes();
+      currentBatchIndex = batchHashes.length - 1;
+    } else {
+      batchHashes = poll.getBatchHashes();
+    }
+
+    uint256 outputBatchHash = batchHashes[currentBatchIndex];
+
+    if (
+      !verifyProcessProof(
+        currentBatchIndex,
+        outputBatchHash,
+        _newSbCommitment,
+        messageBatchSize,
+        voteOptionTreeDepth,
+        _proof
+      )
+    ) {
+      revert InvalidProcessMessageProof();
+    }
+
+    (, uint256 numMessages) = poll.numSignUpsAndMessages();
+
+    updateMessageProcessingData(_newSbCommitment, numMessages <= messageBatchSize * (numBatchesProcessed + 1));
+  }
+
+  /// @inheritdoc IMessageProcessor
+  function getPublicCircuitInputs(
+    uint256 _currentMessageBatchIndex,
+    uint256 _newSbCommitment,
+    uint256 _outputBatchHash
+  ) public view override returns (uint256[] memory publicInputs) {
+    uint256 coordinatorPubKeyHash = poll.coordinatorPubKeyHash();
+    uint8 messageBatchSize = poll.messageBatchSize();
+    (uint256 numSignUps, uint256 numMessages) = poll.numSignUpsAndMessages();
+    uint256 batchEndIndex = _currentMessageBatchIndex * messageBatchSize;
+
+    if (batchEndIndex > numMessages) {
+      batchEndIndex = numMessages;
+    }
+
+    uint256 batchStartIndex = _currentMessageBatchIndex > 0 ? (_currentMessageBatchIndex - 1) * messageBatchSize : 0;
+
+    publicInputs = new uint256[](9);
+    publicInputs[0] = numSignUps;
+    publicInputs[1] = _outputBatchHash;
+    publicInputs[2] = poll.actualStateTreeDepth();
+    publicInputs[3] = coordinatorPubKeyHash;
+    publicInputs[4] = poll.voteOptions();
+    publicInputs[5] = (sbCommitment == 0 ? poll.currentSbCommitment() : sbCommitment);
+    publicInputs[6] = _newSbCommitment;
+    publicInputs[7] = batchStartIndex;
+    publicInputs[8] = batchEndIndex;
+  }
+
+  /// @notice Verify the proof for processMessage
+  /// @dev used to update the sbCommitment
+  /// @param _currentBatchIndex The batch index of current message batch
+  /// @param _outputBatchHash The output batch hash
+  /// @param _newSbCommitment The new sbCommitment after we update this message batch
+  /// @param _messageBatchSize The message batch size
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _proof The zk-SNARK proof
+  /// @return isValid Whether the proof is valid
+  function verifyProcessProof(
+    uint256 _currentBatchIndex,
+    uint256 _outputBatchHash,
+    uint256 _newSbCommitment,
+    uint8 _messageBatchSize,
+    uint8 _voteOptionTreeDepth,
+    uint256[8] memory _proof
+  ) internal view returns (bool isValid) {
+    // get the tree depths
+    // get the message batch size from the message tree subdepth
+    // get the number of signups
+    IMACI maci = poll.getMaciContract();
+
+    uint256[] memory publicCircuitInputs = getPublicCircuitInputs(
+      _currentBatchIndex,
+      _newSbCommitment,
+      _outputBatchHash
+    );
+
+    // Get the verifying key from the VkRegistry
+    VerifyingKey memory vk = vkRegistry.getProcessVk(
+      maci.stateTreeDepth(),
+      _voteOptionTreeDepth,
+      _messageBatchSize,
+      mode
+    );
+
+    isValid = verifier.verify(_proof, vk, publicCircuitInputs);
+  }
+
+  /// @notice update message processing state variables
+  /// @param _newSbCommitment sbCommitment to be updated
+  /// @param _processingComplete update flag that indicate processing is finished or not
+  function updateMessageProcessingData(uint256 _newSbCommitment, bool _processingComplete) internal {
+    sbCommitment = _newSbCommitment;
+    processingComplete = _processingComplete;
+    currentBatchIndex -= 1;
+    numBatchesProcessed++;
+  }
+}

package/contracts/MessageProcessorFactory.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Params } from "./utilities/Params.sol";
+import { DomainObjs } from "./utilities/DomainObjs.sol";
+import { MessageProcessor } from "./MessageProcessor.sol";
+import { IMessageProcessorFactory } from "./interfaces/IMPFactory.sol";
+
+/// @title MessageProcessorFactory
+/// @notice A factory contract which deploys MessageProcessor contracts.
+contract MessageProcessorFactory is Params, DomainObjs, IMessageProcessorFactory {
+  /// @inheritdoc IMessageProcessorFactory
+  function deploy(
+    address _verifier,
+    address _vkRegistry,
+    address _poll,
+    Mode _mode
+  ) public returns (address messageProcessorAddr) {
+    // deploy MessageProcessor for this Poll
+    MessageProcessor messageProcessor = new MessageProcessor(_verifier, _vkRegistry, _poll, _mode);
+    messageProcessorAddr = address(messageProcessor);
+  }
+}