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

package/contracts/VkRegistry.sol

@@ -0,0 +1,413 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { SnarkCommon } from "./crypto/SnarkCommon.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { IVkRegistry } from "./interfaces/IVkRegistry.sol";
+import { DomainObjs } from "./utilities/DomainObjs.sol";
+
+/// @title VkRegistry
+/// @notice Stores verifying keys for the circuits.
+/// Each circuit has a signature which is its compile-time constants represented
+/// as a uint256.
+contract VkRegistry is Ownable(msg.sender), DomainObjs, SnarkCommon, IVkRegistry {
+  mapping(Mode => mapping(uint256 => VerifyingKey)) internal processVks;
+  mapping(Mode => mapping(uint256 => bool)) internal processVkSet;
+
+  mapping(Mode => mapping(uint256 => VerifyingKey)) internal tallyVks;
+  mapping(Mode => mapping(uint256 => bool)) internal tallyVkSet;
+
+  mapping(uint256 => VerifyingKey) internal pollJoiningVks;
+  mapping(uint256 => bool) internal pollJoiningVkSet;
+
+  mapping(uint256 => VerifyingKey) internal pollJoinedVks;
+  mapping(uint256 => bool) internal pollJoinedVkSet;
+
+  event PollJoiningVkSet(uint256 _sig);
+  event PollJoinedVkSet(uint256 _sig);
+  event ProcessVkSet(uint256 _sig, Mode _mode);
+  event TallyVkSet(uint256 _sig, Mode _mode);
+
+  error VkAlreadySet();
+  error VkNotSet();
+  error InvalidKeysParams();
+
+  /// @notice Create a new instance of the VkRegistry contract
+  // solhint-disable-next-line no-empty-blocks
+  constructor() payable {}
+
+  /// @notice Check if the poll joining verifying key is set
+  /// @param _sig The signature
+  /// @return isSet whether the verifying key is set
+  function isPollJoiningVkSet(uint256 _sig) public view returns (bool isSet) {
+    isSet = pollJoiningVkSet[_sig];
+  }
+
+  /// @notice Check if the poll joined verifying key is set
+  /// @param _sig The signature
+  /// @return isSet whether the verifying key is set
+  function isPollJoinedVkSet(uint256 _sig) public view returns (bool isSet) {
+    isSet = pollJoinedVkSet[_sig];
+  }
+
+  /// @notice Check if the process verifying key is set
+  /// @param _sig The signature
+  /// @param _mode QV or Non-QV
+  /// @return isSet whether the verifying key is set
+  function isProcessVkSet(uint256 _sig, Mode _mode) public view returns (bool isSet) {
+    isSet = processVkSet[_mode][_sig];
+  }
+
+  /// @notice Check if the tally verifying key is set
+  /// @param _sig The signature
+  /// @param _mode QV or Non-QV
+  /// @return isSet whether the verifying key is set
+  function isTallyVkSet(uint256 _sig, Mode _mode) public view returns (bool isSet) {
+    isSet = tallyVkSet[_mode][_sig];
+  }
+
+  /// @notice generate the signature for the poll joining verifying key
+  /// @param _stateTreeDepth The state tree depth
+  function genPollJoiningVkSig(uint256 _stateTreeDepth) public pure returns (uint256 sig) {
+    sig = (_stateTreeDepth << 64);
+  }
+
+  /// @notice generate the signature for the poll joined verifying key
+  /// @param _stateTreeDepth The state tree depth
+  function genPollJoinedVkSig(uint256 _stateTreeDepth) public pure returns (uint256 sig) {
+    sig = (_stateTreeDepth << 128);
+  }
+
+  /// @notice generate the signature for the process verifying key
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _messageBatchSize The message batch size
+  function genProcessVkSig(
+    uint256 _stateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize
+  ) public pure returns (uint256 sig) {
+    sig = (_messageBatchSize << 128) + (_stateTreeDepth << 64) + _voteOptionTreeDepth;
+  }
+
+  /// @notice generate the signature for the tally verifying key
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _intStateTreeDepth The intermediate state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @return sig The signature
+  function genTallyVkSig(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth
+  ) public pure returns (uint256 sig) {
+    sig = (_stateTreeDepth << 128) + (_intStateTreeDepth << 64) + _voteOptionTreeDepth;
+  }
+
+  /// @notice Set the process and tally verifying keys for a certain combination
+  /// of parameters and modes
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _intStateTreeDepth The intermediate state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _messageBatchSize The message batch size
+  /// @param _modes Array of QV or Non-QV modes (must have the same length as process and tally keys)
+  /// @param _pollJoiningVk The poll joining verifying key
+  /// @param _pollJoinedVk The poll joined verifying key
+  /// @param _processVks The process verifying keys (must have the same length as modes)
+  /// @param _tallyVks The tally verifying keys (must have the same length as modes)
+  function setVerifyingKeysBatch(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize,
+    Mode[] calldata _modes,
+    VerifyingKey calldata _pollJoiningVk,
+    VerifyingKey calldata _pollJoinedVk,
+    VerifyingKey[] calldata _processVks,
+    VerifyingKey[] calldata _tallyVks
+  ) public onlyOwner {
+    if (_modes.length != _processVks.length || _modes.length != _tallyVks.length) {
+      revert InvalidKeysParams();
+    }
+
+    uint256 length = _modes.length;
+
+    setPollJoiningVkKey(_stateTreeDepth, _pollJoiningVk);
+    setPollJoinedVkKey(_stateTreeDepth, _pollJoinedVk);
+
+    for (uint256 index = 0; index < length; ) {
+      setVerifyingKeys(
+        _stateTreeDepth,
+        _intStateTreeDepth,
+        _voteOptionTreeDepth,
+        _messageBatchSize,
+        _modes[index],
+        _processVks[index],
+        _tallyVks[index]
+      );
+
+      unchecked {
+        index++;
+      }
+    }
+  }
+
+  /// @notice Set the process and tally verifying keys for a certain combination
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _intStateTreeDepth The intermediate state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _messageBatchSize The message batch size
+  /// @param _mode QV or Non-QV
+  /// @param _processVk The process verifying key
+  /// @param _tallyVk The tally verifying key
+  function setVerifyingKeys(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize,
+    Mode _mode,
+    VerifyingKey calldata _processVk,
+    VerifyingKey calldata _tallyVk
+  ) public onlyOwner {
+    setProcessVkKey(_stateTreeDepth, _voteOptionTreeDepth, _messageBatchSize, _mode, _processVk);
+    setTallyVkKey(_stateTreeDepth, _intStateTreeDepth, _voteOptionTreeDepth, _mode, _tallyVk);
+  }
+
+  /// @notice Set the process verifying key for a certain combination of parameters
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _messageBatchSize The message batch size
+  /// @param _mode QV or Non-QV
+  /// @param _processVk The process verifying key
+  function setProcessVkKey(
+    uint256 _stateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize,
+    Mode _mode,
+    VerifyingKey calldata _processVk
+  ) public onlyOwner {
+    uint256 processVkSig = genProcessVkSig(_stateTreeDepth, _voteOptionTreeDepth, _messageBatchSize);
+
+    if (processVkSet[_mode][processVkSig]) revert VkAlreadySet();
+
+    VerifyingKey storage processVk = processVks[_mode][processVkSig];
+    processVk.alpha1 = _processVk.alpha1;
+    processVk.beta2 = _processVk.beta2;
+    processVk.gamma2 = _processVk.gamma2;
+    processVk.delta2 = _processVk.delta2;
+
+    uint256 processIcLength = _processVk.ic.length;
+    for (uint256 i = 0; i < processIcLength; ) {
+      processVk.ic.push(_processVk.ic[i]);
+
+      unchecked {
+        i++;
+      }
+    }
+
+    processVkSet[_mode][processVkSig] = true;
+
+    emit ProcessVkSet(processVkSig, _mode);
+  }
+
+  /// @notice Set the tally verifying key for a certain combination of parameters
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _intStateTreeDepth The intermediate state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _mode QV or Non-QV
+  /// @param _tallyVk The tally verifying key
+  function setTallyVkKey(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    Mode _mode,
+    VerifyingKey calldata _tallyVk
+  ) public onlyOwner {
+    uint256 tallyVkSig = genTallyVkSig(_stateTreeDepth, _intStateTreeDepth, _voteOptionTreeDepth);
+
+    if (tallyVkSet[_mode][tallyVkSig]) revert VkAlreadySet();
+
+    VerifyingKey storage tallyVk = tallyVks[_mode][tallyVkSig];
+    tallyVk.alpha1 = _tallyVk.alpha1;
+    tallyVk.beta2 = _tallyVk.beta2;
+    tallyVk.gamma2 = _tallyVk.gamma2;
+    tallyVk.delta2 = _tallyVk.delta2;
+
+    uint256 tallyIcLength = _tallyVk.ic.length;
+    for (uint256 i = 0; i < tallyIcLength; ) {
+      tallyVk.ic.push(_tallyVk.ic[i]);
+
+      unchecked {
+        i++;
+      }
+    }
+
+    tallyVkSet[_mode][tallyVkSig] = true;
+
+    emit TallyVkSet(tallyVkSig, _mode);
+  }
+
+  /// @notice Set the poll joining verifying key for a certain combination of parameters
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _pollJoiningVk The poll joining verifying key
+  function setPollJoiningVkKey(uint256 _stateTreeDepth, VerifyingKey calldata _pollJoiningVk) public onlyOwner {
+    uint256 pollJoiningVkSig = genPollJoiningVkSig(_stateTreeDepth);
+
+    if (pollJoiningVkSet[pollJoiningVkSig]) revert VkAlreadySet();
+
+    VerifyingKey storage pollJoiningVk = pollJoiningVks[pollJoiningVkSig];
+    pollJoiningVk.alpha1 = _pollJoiningVk.alpha1;
+    pollJoiningVk.beta2 = _pollJoiningVk.beta2;
+    pollJoiningVk.gamma2 = _pollJoiningVk.gamma2;
+    pollJoiningVk.delta2 = _pollJoiningVk.delta2;
+
+    uint256 pollIcLength = _pollJoiningVk.ic.length;
+    for (uint256 i = 0; i < pollIcLength; ) {
+      pollJoiningVk.ic.push(_pollJoiningVk.ic[i]);
+
+      unchecked {
+        i++;
+      }
+    }
+
+    pollJoiningVkSet[pollJoiningVkSig] = true;
+
+    emit PollJoiningVkSet(pollJoiningVkSig);
+  }
+
+  /// @notice Set the poll joined verifying key for a certain combination of parameters
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _pollJoinedVk The poll joined verifying key
+  function setPollJoinedVkKey(uint256 _stateTreeDepth, VerifyingKey calldata _pollJoinedVk) public onlyOwner {
+    uint256 pollJoinedVkSig = genPollJoinedVkSig(_stateTreeDepth);
+
+    if (pollJoinedVkSet[pollJoinedVkSig]) revert VkAlreadySet();
+
+    VerifyingKey storage pollJoinedVk = pollJoinedVks[pollJoinedVkSig];
+    pollJoinedVk.alpha1 = _pollJoinedVk.alpha1;
+    pollJoinedVk.beta2 = _pollJoinedVk.beta2;
+    pollJoinedVk.gamma2 = _pollJoinedVk.gamma2;
+    pollJoinedVk.delta2 = _pollJoinedVk.delta2;
+
+    uint256 pollIcLength = _pollJoinedVk.ic.length;
+    for (uint256 i = 0; i < pollIcLength; ) {
+      pollJoinedVk.ic.push(_pollJoinedVk.ic[i]);
+
+      unchecked {
+        i++;
+      }
+    }
+
+    pollJoinedVkSet[pollJoinedVkSig] = true;
+
+    emit PollJoinedVkSet(pollJoinedVkSig);
+  }
+
+  /// @notice Check if the process verifying key is set
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _messageBatchSize The message batch size
+  /// @param _mode QV or Non-QV
+  /// @return isSet whether the verifying key is set
+  function hasProcessVk(
+    uint256 _stateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize,
+    Mode _mode
+  ) public view returns (bool isSet) {
+    uint256 sig = genProcessVkSig(_stateTreeDepth, _voteOptionTreeDepth, _messageBatchSize);
+    isSet = processVkSet[_mode][sig];
+  }
+
+  /// @notice Get the process verifying key by signature
+  /// @param _sig The signature
+  /// @param _mode QV or Non-QV
+  /// @return vk The verifying key
+  function getProcessVkBySig(uint256 _sig, Mode _mode) public view returns (VerifyingKey memory vk) {
+    if (!processVkSet[_mode][_sig]) revert VkNotSet();
+
+    vk = processVks[_mode][_sig];
+  }
+
+  /// @inheritdoc IVkRegistry
+  function getProcessVk(
+    uint256 _stateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    uint8 _messageBatchSize,
+    Mode _mode
+  ) public view returns (VerifyingKey memory vk) {
+    uint256 sig = genProcessVkSig(_stateTreeDepth, _voteOptionTreeDepth, _messageBatchSize);
+
+    vk = getProcessVkBySig(sig, _mode);
+  }
+
+  /// @notice Check if the tally verifying key is set
+  /// @param _stateTreeDepth The state tree depth
+  /// @param _intStateTreeDepth The intermediate state tree depth
+  /// @param _voteOptionTreeDepth The vote option tree depth
+  /// @param _mode QV or Non-QV
+  /// @return isSet whether the verifying key is set
+  function hasTallyVk(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    Mode _mode
+  ) public view returns (bool isSet) {
+    uint256 sig = genTallyVkSig(_stateTreeDepth, _intStateTreeDepth, _voteOptionTreeDepth);
+
+    isSet = tallyVkSet[_mode][sig];
+  }
+
+  /// @notice Get the tally verifying key by signature
+  /// @param _sig The signature
+  /// @param _mode QV or Non-QV
+  /// @return vk The verifying key
+  function getTallyVkBySig(uint256 _sig, Mode _mode) public view returns (VerifyingKey memory vk) {
+    if (!tallyVkSet[_mode][_sig]) revert VkNotSet();
+
+    vk = tallyVks[_mode][_sig];
+  }
+
+  /// @inheritdoc IVkRegistry
+  function getTallyVk(
+    uint256 _stateTreeDepth,
+    uint256 _intStateTreeDepth,
+    uint256 _voteOptionTreeDepth,
+    Mode _mode
+  ) public view returns (VerifyingKey memory vk) {
+    uint256 sig = genTallyVkSig(_stateTreeDepth, _intStateTreeDepth, _voteOptionTreeDepth);
+
+    vk = getTallyVkBySig(sig, _mode);
+  }
+
+  /// @notice Get the poll joining verifying key by signature
+  /// @param _sig The signature
+  /// @return vk The verifying key
+  function getPollJoiningVkBySig(uint256 _sig) public view returns (VerifyingKey memory vk) {
+    if (!pollJoiningVkSet[_sig]) revert VkNotSet();
+
+    vk = pollJoiningVks[_sig];
+  }
+
+  /// @notice Get the poll joined verifying key by signature
+  /// @param _sig The signature
+  /// @return vk The verifying key
+  function getPollJoinedVkBySig(uint256 _sig) public view returns (VerifyingKey memory vk) {
+    if (!pollJoinedVkSet[_sig]) revert VkNotSet();
+
+    vk = pollJoinedVks[_sig];
+  }
+
+  /// @inheritdoc IVkRegistry
+  function getPollJoiningVk(uint256 _stateTreeDepth) public view returns (VerifyingKey memory vk) {
+    uint256 sig = genPollJoiningVkSig(_stateTreeDepth);
+
+    vk = getPollJoiningVkBySig(sig);
+  }
+
+  /// @inheritdoc IVkRegistry
+  function getPollJoinedVk(uint256 _stateTreeDepth) public view returns (VerifyingKey memory vk) {
+    uint256 sig = genPollJoinedVkSig(_stateTreeDepth);
+
+    vk = getPollJoinedVkBySig(sig);
+  }
+}

package/contracts/benchmarks/HasherBenchmarks.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Hasher } from "../crypto/Hasher.sol";
+
+/// @title HasherBenchmarks
+/// @notice A contract used to benchmark the poseidon hash function
+contract HasherBenchmarks is Hasher {
+  /// @notice Benchmark the poseidon hash function with 5 inputs
+  /// @param array The array of inputs to hash
+  /// @return result The hash of the inputs
+  function hash5Benchmark(uint256[5] memory array) public pure returns (uint256 result) {
+    result = hash5(array);
+  }
+
+  /// @notice Benchmark the poseidon hash function with 2 inputs
+  /// @param _left The left input to hash
+  /// @param _right The right input to hash
+  /// @return result The hash of the two inputs
+  function hashLeftRightBenchmark(uint256 _left, uint256 _right) public pure returns (uint256 result) {
+    result = hashLeftRight(_left, _right);
+  }
+}

package/contracts/crypto/BabyJubJub.sol

@@ -0,0 +1,138 @@
+// @note This code was taken from
+// https://github.com/yondonfu/sol-baby-jubjub/blob/master/contracts/CurveBabyJubJub.sol
+// Thanks to yondonfu for the code
+// Implementation cited on baby-jubjub's paper
+// https://eips.ethereum.org/EIPS/eip-2494#implementation
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+library CurveBabyJubJub {
+  // Curve parameters
+  // E: 168700x^2 + y^2 = 1 + 168696x^2y^2
+  // A = 168700
+  uint256 public constant A = 0x292FC;
+  // D = 168696
+  uint256 public constant D = 0x292F8;
+  // Prime Q = 21888242871839275222246405745257275088548364400416034343698204186575808495617
+  uint256 public constant Q = 0x30644E72E131A029B85045B68181585D2833E84879B9709143E1F593F0000001;
+
+  /**
+   * @dev Add 2 points on baby jubjub curve
+   * Formula for adding 2 points on a twisted Edwards curve:
+   * x3 = (x1y2 + y1x2) / (1 + dx1x2y1y2)
+   * y3 = (y1y2 - ax1x2) / (1 - dx1x2y1y2)
+   */
+  function pointAdd(uint256 _x1, uint256 _y1, uint256 _x2, uint256 _y2) internal view returns (uint256 x3, uint256 y3) {
+    if (_x1 == 0 && _y1 == 0) {
+      return (_x2, _y2);
+    }
+
+    if (_x2 == 0 && _y1 == 0) {
+      return (_x1, _y1);
+    }
+
+    uint256 x1x2 = mulmod(_x1, _x2, Q);
+    uint256 y1y2 = mulmod(_y1, _y2, Q);
+    uint256 dx1x2y1y2 = mulmod(D, mulmod(x1x2, y1y2, Q), Q);
+    uint256 x3Num = addmod(mulmod(_x1, _y2, Q), mulmod(_y1, _x2, Q), Q);
+    uint256 y3Num = submod(y1y2, mulmod(A, x1x2, Q), Q);
+
+    x3 = mulmod(x3Num, inverse(addmod(1, dx1x2y1y2, Q)), Q);
+    y3 = mulmod(y3Num, inverse(submod(1, dx1x2y1y2, Q)), Q);
+  }
+
+  /**
+   * @dev Double a point on baby jubjub curve
+   * Doubling can be performed with the same formula as addition
+   */
+  function pointDouble(uint256 _x1, uint256 _y1) internal view returns (uint256 x2, uint256 y2) {
+    return pointAdd(_x1, _y1, _x1, _y1);
+  }
+
+  /**
+   * @dev Multiply a point on baby jubjub curve by a scalar
+   * Use the double and add algorithm
+   */
+  function pointMul(uint256 _x1, uint256 _y1, uint256 _d) internal view returns (uint256 x2, uint256 y2) {
+    uint256 remaining = _d;
+
+    uint256 px = _x1;
+    uint256 py = _y1;
+    uint256 ax = 0;
+    uint256 ay = 0;
+
+    while (remaining != 0) {
+      if ((remaining & 1) != 0) {
+        // Binary digit is 1 so add
+        (ax, ay) = pointAdd(ax, ay, px, py);
+      }
+
+      (px, py) = pointDouble(px, py);
+
+      remaining = remaining / 2;
+    }
+
+    x2 = ax;
+    y2 = ay;
+  }
+
+  /**
+   * @dev Check if a given point is on the curve
+   * (168700x^2 + y^2) - (1 + 168696x^2y^2) == 0
+   */
+  function isOnCurve(uint256 _x, uint256 _y) internal pure returns (bool) {
+    uint256 xSq = mulmod(_x, _x, Q);
+    uint256 ySq = mulmod(_y, _y, Q);
+    uint256 lhs = addmod(mulmod(A, xSq, Q), ySq, Q);
+    uint256 rhs = addmod(1, mulmod(mulmod(D, xSq, Q), ySq, Q), Q);
+    return submod(lhs, rhs, Q) == 0;
+  }
+
+  /**
+   * @dev Perform modular subtraction
+   */
+  function submod(uint256 _a, uint256 _b, uint256 _mod) internal pure returns (uint256) {
+    uint256 aNN = _a;
+
+    if (_a <= _b) {
+      aNN += _mod;
+    }
+
+    return addmod(aNN - _b, 0, _mod);
+  }
+
+  /**
+   * @dev Compute modular inverse of a number
+   */
+  function inverse(uint256 _a) internal view returns (uint256) {
+    // We can use Euler's theorem instead of the extended Euclidean algorithm
+    // Since m = Q and Q is prime we have: a^-1 = a^(m - 2) (mod m)
+    return expmod(_a, Q - 2, Q);
+  }
+
+  /**
+   * @dev Helper function to call the bigModExp precompile
+   */
+  function expmod(uint256 _b, uint256 _e, uint256 _m) internal view returns (uint256 o) {
+    assembly {
+      let memPtr := mload(0x40)
+      mstore(memPtr, 0x20) // Length of base _b
+      mstore(add(memPtr, 0x20), 0x20) // Length of exponent _e
+      mstore(add(memPtr, 0x40), 0x20) // Length of modulus _m
+      mstore(add(memPtr, 0x60), _b) // Base _b
+      mstore(add(memPtr, 0x80), _e) // Exponent _e
+      mstore(add(memPtr, 0xa0), _m) // Modulus _m
+
+      // The bigModExp precompile is at 0x05
+      let success := staticcall(gas(), 0x05, memPtr, 0xc0, memPtr, 0x20)
+      switch success
+      case 0 {
+        revert(0x0, 0x0)
+      }
+      default {
+        o := mload(memPtr)
+      }
+    }
+  }
+}

package/contracts/crypto/Hasher.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { SnarkConstants } from "./SnarkConstants.sol";
+import { PoseidonT3 } from "./PoseidonT3.sol";
+import { PoseidonT4 } from "./PoseidonT4.sol";
+import { PoseidonT5 } from "./PoseidonT5.sol";
+import { PoseidonT6 } from "./PoseidonT6.sol";
+
+/// @notice A SHA256 hash function for any number of input elements, and Poseidon hash
+/// functions for 2, 3, 4, 5, and 12 input elements.
+contract Hasher is SnarkConstants {
+  /// @notice Computes the SHA256 hash of an array of uint256 elements.
+  /// @param array The array of uint256 elements.
+  /// @return result The SHA256 hash of the array.
+  function sha256Hash(uint256[] memory array) public pure returns (uint256 result) {
+    result = uint256(sha256(abi.encodePacked(array))) % SNARK_SCALAR_FIELD;
+  }
+
+  /// @notice Computes the Poseidon hash of two uint256 elements.
+  /// @param array An array of two uint256 elements.
+  /// @return result The Poseidon hash of the two elements.
+  function hash2(uint256[2] memory array) public pure returns (uint256 result) {
+    result = PoseidonT3.poseidon(array);
+  }
+
+  /// @notice Computes the Poseidon hash of three uint256 elements.
+  /// @param array An array of three uint256 elements.
+  /// @return result The Poseidon hash of the three elements.
+  function hash3(uint256[3] memory array) public pure returns (uint256 result) {
+    result = PoseidonT4.poseidon(array);
+  }
+
+  /// @notice Computes the Poseidon hash of four uint256 elements.
+  /// @param array An array of four uint256 elements.
+  /// @return result The Poseidon hash of the four elements.
+  function hash4(uint256[4] memory array) public pure returns (uint256 result) {
+    result = PoseidonT5.poseidon(array);
+  }
+
+  /// @notice Computes the Poseidon hash of five uint256 elements.
+  /// @param array An array of five uint256 elements.
+  /// @return result The Poseidon hash of the five elements.
+  function hash5(uint256[5] memory array) public pure returns (uint256 result) {
+    result = PoseidonT6.poseidon(array);
+  }
+
+  /// @notice Computes the Poseidon hash of two uint256 elements.
+  /// @param left the first element to hash.
+  /// @param right the second element to hash.
+  /// @return result The Poseidon hash of the two elements.
+  function hashLeftRight(uint256 left, uint256 right) public pure returns (uint256 result) {
+    uint256[2] memory input;
+    input[0] = left;
+    input[1] = right;
+    result = hash2(input);
+  }
+}