@lfdecentralizedtrust/zeto-contracts 0.2.1 → 0.5.0

package/contracts/zeto_anon_nullifier.sol

@@ -15,51 +15,39 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {IZeto} from "./lib/interfaces/izeto.sol";
-import {MAX_BATCH} from "./lib/interfaces/izeto.sol";
-import {Groth16Verifier_Deposit} from "./verifiers/verifier_deposit.sol";
-import {Groth16Verifier_WithdrawNullifier} from "./verifiers/verifier_withdraw_nullifier.sol";
-import {Groth16Verifier_WithdrawNullifierBatch} from "./verifiers/verifier_withdraw_nullifier_batch.sol";
-import {Groth16Verifier_AnonNullifierTransfer} from "./verifiers/verifier_anon_nullifier_transfer.sol";
-import {Groth16Verifier_AnonNullifierTransferLocked} from "./verifiers/verifier_anon_nullifier_transferLocked.sol";
-import {Groth16Verifier_AnonNullifierTransferBatch} from "./verifiers/verifier_anon_nullifier_transfer_batch.sol";
-import {Groth16Verifier_AnonNullifierTransferLockedBatch} from "./verifiers/verifier_anon_nullifier_transferLocked_batch.sol";
-import {ZetoNullifier} from "./lib/zeto_nullifier.sol";
-import {ZetoFungibleWithdrawWithNullifiers} from "./lib/zeto_fungible_withdraw_nullifier.sol";
-import {Commonlib} from "./lib/common.sol";
-import {IZetoInitializable} from "./lib/interfaces/izeto_initializable.sol";
+import {IZeto, MAX_BATCH} from "./lib/interfaces/IZeto.sol";
+import {ZetoFungibleNullifier} from "./lib/zeto_fungible_nullifier.sol";
+import {Commonlib} from "./lib/common/common.sol";
+import {IZetoInitializable} from "./lib/interfaces/IZetoInitializable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import {console} from "hardhat/console.sol";
-
-uint256 constant INPUT_SIZE = 7;
-uint256 constant INPUT_SIZE_LOCKED = 8;
-uint256 constant BATCH_INPUT_SIZE = 31;
-uint256 constant BATCH_INPUT_SIZE_LOCKED = 32;
 
 /// @title A sample implementation of a Zeto based fungible token with anonymity and history masking
 /// @author Kaleido, Inc.
+/// @notice Decimals: this token uses **4** decimals, inherited from
+///         {ZetoCommon.decimals}. Indexers and UIs reading this contract
+///         directly should treat balances accordingly.
 /// @dev The proof has the following statements:
 ///        - each value in the output commitments must be a positive number in the range 0 ~ (2\*\*40 - 1)
 ///        - the sum of the nullified values match the sum of output values
 ///        - the hashes in the input and output match the hash(value, salt, owner public key) formula
 ///        - the sender possesses the private BabyJubjub key, whose public key is part of the pre-image of the input commitment hashes, which match the corresponding nullifiers
 ///        - the nullifiers represent input commitments that are included in a Sparse Merkle Tree represented by the root hash
-contract Zeto_AnonNullifier is
-    IZeto,
-    IZetoInitializable,
-    ZetoNullifier,
-    ZetoFungibleWithdrawWithNullifiers,
-    UUPSUpgradeable
-{
-    Groth16Verifier_AnonNullifierTransfer internal _verifier;
-    Groth16Verifier_AnonNullifierTransferBatch internal _batchVerifier;
-    Groth16Verifier_AnonNullifierTransferLocked internal _lockVerifier;
-    Groth16Verifier_AnonNullifierTransferLockedBatch
-        internal _batchLockVerifier;
+contract Zeto_AnonNullifier is ZetoFungibleNullifier, UUPSUpgradeable {
+    /// @dev Lock the implementation contract on construction so that
+    ///      {initialize} can only ever run on a proxy. Without this,
+    ///      anyone could call {initialize} directly on the deployed
+    ///      implementation, become its owner, and then `upgradeTo(any)`
+    ///      via {_authorizeUpgrade} (the OZ "implementation takeover"
+    ///      pattern, CVE-2022-35961 family). See OpenZeppelin's
+    ///      `Initializable._disableInitializers` for the rationale.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
 
     function initialize(
-        string memory name,
-        string memory symbol,
+        string calldata name,
+        string calldata symbol,
         address initialOwner,
         IZetoInitializable.VerifiersInfo calldata verifiers
     ) public virtual initializer {
@@ -67,29 +55,12 @@ contract Zeto_AnonNullifier is
     }
 
     function __ZetoAnonNullifier_init(
-        string memory name_,
-        string memory symbol_,
+        string calldata name_,
+        string calldata symbol_,
         address initialOwner,
         IZetoInitializable.VerifiersInfo calldata verifiers
     ) internal onlyInitializing {
-        __ZetoNullifier_init(name_, symbol_, initialOwner);
-        __ZetoFungibleWithdrawWithNullifiers_init(
-            (Groth16Verifier_Deposit)(verifiers.depositVerifier),
-            (Groth16Verifier_WithdrawNullifier)(verifiers.withdrawVerifier),
-            (Groth16Verifier_WithdrawNullifierBatch)(
-                verifiers.batchWithdrawVerifier
-            )
-        );
-        _verifier = (Groth16Verifier_AnonNullifierTransfer)(verifiers.verifier);
-        _lockVerifier = (Groth16Verifier_AnonNullifierTransferLocked)(
-            verifiers.lockVerifier
-        );
-        _batchVerifier = (Groth16Verifier_AnonNullifierTransferBatch)(
-            verifiers.batchVerifier
-        );
-        _batchLockVerifier = (Groth16Verifier_AnonNullifierTransferLockedBatch)(
-            verifiers.batchLockVerifier
-        );
+        __ZetoFungibleNullifier_init(name_, symbol_, initialOwner, verifiers);
     }
 
     function _authorizeUpgrade(address) internal override onlyOwner {}
@@ -97,284 +68,179 @@ contract Zeto_AnonNullifier is
     function constructPublicInputs(
         uint256[] memory nullifiers,
         uint256[] memory outputs,
-        uint256 root,
-        uint256 size,
-        bool locked
-    ) internal view returns (uint256[] memory publicInputs) {
-        publicInputs = new uint256[](size);
-        uint256 piIndex = 0;
-        // copy input commitments
-        for (uint256 i = 0; i < nullifiers.length; i++) {
-            publicInputs[piIndex++] = nullifiers[i];
-        }
-        // when verifying locked transfers, additional public input
-        // for the lock delegate
-        if (locked) {
-            publicInputs[piIndex++] = uint256(uint160(msg.sender));
+        bytes memory proof,
+        bool inputsLocked
+    )
+        internal
+        virtual
+        override
+        returns (uint256[] memory, Commonlib.Proof memory)
+    {
+        // Decode the proof to extract root and proof structure. Done once
+        // here so that {validateTransactionProposal} below can skip the
+        // root-only pre-decode it used to perform; root validation happens
+        // here instead.
+        uint256 root;
+        Commonlib.Proof memory proofStruct;
+        if (!inputsLocked) {
+            (root, proofStruct) = abi.decode(proof, (uint256, Commonlib.Proof));
+            validateRoot(root);
+        } else {
+            proofStruct = abi.decode(proof, (Commonlib.Proof));
         }
-        // copy root
-        publicInputs[piIndex++] = root;
 
-        // populate enables
-        for (uint256 i = 0; i < nullifiers.length; i++) {
-            publicInputs[piIndex++] = (nullifiers[i] == 0) ? 0 : 1;
-        }
+        // Get extra inputs from derived contracts
+        uint256[] memory extra = extraInputs();
 
-        // copy output commitments
-        for (uint256 i = 0; i < outputs.length; i++) {
-            publicInputs[piIndex++] = outputs[i];
-        }
+        // Calculate the total size needed for public inputs
+        uint256 size = _calculatePublicInputsSize(
+            nullifiers,
+            outputs,
+            extra,
+            inputsLocked
+        );
 
-        return publicInputs;
+        // Create and populate the public inputs array
+        uint256[] memory publicInputs = new uint256[](size);
+        _fillPublicInputs(
+            publicInputs,
+            nullifiers,
+            outputs,
+            extra,
+            root,
+            inputsLocked
+        );
+
+        return (publicInputs, proofStruct);
     }
 
-    /**
-     * @dev the main function of the contract.
-     *
-     * @param nullifiers Array of nullifiers that are secretly bound to UTXOs to be spent by the transaction.
-     * @param outputs Array of new UTXOs to generate, for future transactions to spend.
-     * @param root The root hash of the Sparse Merkle Tree that contains the nullifiers.
-     * @param proof A zero knowledge proof that the submitter is authorized to spend the inputs, and
-     *      that the outputs are valid in terms of obeying mass conservation rules.
-     *
-     * Emits a {UTXOTransfer} event.
-     */
-    function transfer(
-        uint256[] memory nullifiers,
+    function _calculatePublicInputsSize(
+        uint256[] memory inputs,
         uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        nullifiers = checkAndPadCommitments(nullifiers);
-        outputs = checkAndPadCommitments(outputs);
-        validateTransactionProposal(nullifiers, outputs, root, false);
-        verifyProof(nullifiers, outputs, root, proof);
-        uint256[] memory empty;
-        processInputsAndOutputs(nullifiers, outputs, empty, address(0));
-
-        uint256[] memory nullifierArray = new uint256[](nullifiers.length);
-        uint256[] memory outputArray = new uint256[](outputs.length);
-        for (uint256 i = 0; i < nullifiers.length; ++i) {
-            nullifierArray[i] = nullifiers[i];
-            outputArray[i] = outputs[i];
+        uint256[] memory extra,
+        bool inputsLocked
+    ) internal pure returns (uint256 size) {
+        if (inputsLocked) {
+            // locked inputs are UTXOs not nullifiers
+            size =
+                inputs.length +
+                extra.length + // extra inputs
+                outputs.length; // output commitments
+        } else {
+            size =
+                (inputs.length * 2) + // nullifiers and enabled flags
+                1 + // root
+                extra.length + // extra inputs
+                outputs.length; // output commitments
         }
-        emit UTXOTransfer(nullifierArray, outputArray, msg.sender, data);
-        return true;
     }
 
-    function transferLocked(
-        uint256[] memory nullifiers,
+    function _fillPublicInputs(
+        uint256[] memory publicInputs,
+        uint256[] memory inputs,
         uint256[] memory outputs,
+        uint256[] memory extra,
         uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        nullifiers = checkAndPadCommitments(nullifiers);
-        outputs = checkAndPadCommitments(outputs);
-        validateTransactionProposal(nullifiers, outputs, root, true);
-        verifyProofLocked(nullifiers, outputs, root, proof);
-        uint256[] memory empty;
-        processInputsAndOutputs(nullifiers, outputs, empty, address(0));
+        bool inputsLocked
+    ) internal view {
+        uint256 piIndex = 0;
+
+        if (!inputsLocked) {
+            // Copy nullifiers
+            piIndex = _fillInputs_Nullifier(publicInputs, inputs, piIndex);
 
-        uint256[] memory nullifierArray = new uint256[](nullifiers.length);
-        uint256[] memory outputArray = new uint256[](outputs.length);
-        for (uint256 i = 0; i < nullifiers.length; ++i) {
-            nullifierArray[i] = nullifiers[i];
-            outputArray[i] = outputs[i];
+            // Copy root
+            publicInputs[piIndex++] = root;
+
+            // Populate enabled flags
+            piIndex = _fillEnabledFlags_Nullifier(
+                publicInputs,
+                inputs,
+                piIndex
+            );
+
+            // Copy extra inputs
+            piIndex = _fillExtraInputs_Nullifier(publicInputs, extra, piIndex);
+
+            // Copy output commitments
+            _fillOutputCommitments_Nullifier(publicInputs, outputs, piIndex);
+        } else {
+            // Copy inputs
+            piIndex = _fillInputs_Nullifier(publicInputs, inputs, piIndex);
+
+            // Copy extra inputs
+            piIndex = _fillExtraInputs_Nullifier(publicInputs, extra, piIndex);
+
+            // Copy output commitments
+            _fillOutputCommitments_Nullifier(publicInputs, outputs, piIndex);
         }
-        emit UTXOTransfer(nullifierArray, outputArray, msg.sender, data);
-        return true;
     }
 
-    function deposit(
-        uint256 amount,
-        uint256[] memory outputs,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public {
-        _deposit(amount, outputs, proof);
-        _mint(outputs, data);
+    function _fillInputs_Nullifier(
+        uint256[] memory publicInputs,
+        uint256[] memory inputs,
+        uint256 startIndex
+    ) internal pure returns (uint256 nextIndex) {
+        uint256 piIndex = startIndex;
+        for (uint256 i = 0; i < inputs.length; i++) {
+            publicInputs[piIndex++] = inputs[i];
+        }
+        return piIndex;
     }
 
-    function withdraw(
-        uint256 amount,
+    function _fillEnabledFlags_Nullifier(
+        uint256[] memory publicInputs,
         uint256[] memory nullifiers,
-        uint256 output,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public {
-        uint256[] memory outputs = new uint256[](nullifiers.length);
-        outputs[0] = output;
-        // Check and pad inputs and outputs based on the max size
-        nullifiers = checkAndPadCommitments(nullifiers);
-        outputs = checkAndPadCommitments(outputs);
-        validateTransactionProposal(nullifiers, outputs, root, false);
-        _withdrawWithNullifiers(amount, nullifiers, output, root, proof);
-        uint256[] memory empty;
-        processInputsAndOutputs(nullifiers, outputs, empty, address(0));
-        emit UTXOWithdraw(amount, nullifiers, output, msg.sender, data);
+        uint256 startIndex
+    ) internal pure returns (uint256 nextIndex) {
+        uint256 piIndex = startIndex;
+        for (uint256 i = 0; i < nullifiers.length; i++) {
+            publicInputs[piIndex++] = (nullifiers[i] == 0) ? 0 : 1;
+        }
+        return piIndex;
     }
 
-    function mint(
-        uint256[] memory utxos,
-        bytes calldata data
-    ) public onlyOwner {
-        _mint(utxos, data);
+    function _fillExtraInputs_Nullifier(
+        uint256[] memory publicInputs,
+        uint256[] memory extra,
+        uint256 startIndex
+    ) internal pure returns (uint256 nextIndex) {
+        uint256 piIndex = startIndex;
+        for (uint256 i = 0; i < extra.length; i++) {
+            publicInputs[piIndex++] = extra[i];
+        }
+        return piIndex;
     }
 
-    function lock(
-        uint256[] memory nullifiers,
+    function _fillOutputCommitments_Nullifier(
+        uint256[] memory publicInputs,
         uint256[] memory outputs,
-        uint256[] memory lockedOutputs,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        address delegate,
-        bytes calldata data
-    ) public {
-        // merge the outputs and lockedOutputs and do a regular transfer
-        uint256[] memory allOutputs = new uint256[](
-            outputs.length + lockedOutputs.length
-        );
+        uint256 startIndex
+    ) internal pure {
+        uint256 piIndex = startIndex;
         for (uint256 i = 0; i < outputs.length; i++) {
-            allOutputs[i] = outputs[i];
-        }
-        for (uint256 i = 0; i < lockedOutputs.length; i++) {
-            allOutputs[outputs.length + i] = lockedOutputs[i];
+            publicInputs[piIndex++] = outputs[i];
         }
-        nullifiers = checkAndPadCommitments(nullifiers);
-        allOutputs = checkAndPadCommitments(allOutputs);
-        validateTransactionProposal(nullifiers, allOutputs, root, false);
-        verifyProof(nullifiers, allOutputs, root, proof);
-
-        processNullifiers(nullifiers);
-
-        // lock the intended outputs
-        _lock(nullifiers, outputs, lockedOutputs, delegate, data);
     }
 
-    function unlock(
-        uint256[] memory nullifiers,
-        uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public {
-        transferLocked(nullifiers, outputs, root, proof, data);
+    function extraInputs() internal view virtual returns (uint256[] memory) {
+        // no extra inputs for this contract
+        return new uint256[](0);
     }
+}
 
-    function verifyProof(
-        uint256[] memory nullifiers,
-        uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof
-    ) public view returns (bool) {
-        if (nullifiers.length > 2 || outputs.length > 2) {
-            uint256[] memory publicInputs = constructPublicInputs(
-                nullifiers,
-                outputs,
-                root,
-                BATCH_INPUT_SIZE,
-                false
-            );
-            // construct the public inputs for batchVerifier
-            uint256[BATCH_INPUT_SIZE] memory fixedSizeInputs;
-            for (uint256 i = 0; i < fixedSizeInputs.length; i++) {
-                fixedSizeInputs[i] = publicInputs[i];
-            }
-
-            // Check the proof using batchVerifier
-            require(
-                _batchVerifier.verifyProof(
-                    proof.pA,
-                    proof.pB,
-                    proof.pC,
-                    fixedSizeInputs
-                ),
-                "Invalid proof (batch)"
-            );
-        } else {
-            uint256[] memory publicInputs = constructPublicInputs(
-                nullifiers,
-                outputs,
-                root,
-                INPUT_SIZE,
-                false
-            );
-            // construct the public inputs for verifier
-            uint256[INPUT_SIZE] memory fixedSizeInputs;
-            for (uint256 i = 0; i < fixedSizeInputs.length; i++) {
-                fixedSizeInputs[i] = publicInputs[i];
-            }
-            // Check the proof
-            require(
-                _verifier.verifyProof(
-                    proof.pA,
-                    proof.pB,
-                    proof.pC,
-                    fixedSizeInputs
-                ),
-                "Invalid proof"
-            );
-        }
-        return true;
+/// @dev ERC-7201 (`erc7201:zeto.storage.Zeto_AnonNullifier`).
+library Zeto_AnonNullifierStorage {
+    struct Layout {
+        uint256 __reserved;
     }
 
-    function verifyProofLocked(
-        uint256[] memory nullifiers,
-        uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof
-    ) public view returns (bool) {
-        if (nullifiers.length > 2 || outputs.length > 2) {
-            uint256[] memory publicInputs = constructPublicInputs(
-                nullifiers,
-                outputs,
-                root,
-                BATCH_INPUT_SIZE_LOCKED,
-                true
-            );
-            // construct the public inputs for batchVerifier
-            uint256[BATCH_INPUT_SIZE_LOCKED] memory fixedSizeInputs;
-            for (uint256 i = 0; i < fixedSizeInputs.length; i++) {
-                fixedSizeInputs[i] = publicInputs[i];
-            }
+    bytes32 private constant STORAGE_LOCATION =
+        0xe49aec919d5bc8263575d088c75c14f60ed5ec12d5e1b7a7a34166fca4de8b00;
 
-            // Check the proof using batchVerifier
-            require(
-                _batchLockVerifier.verifyProof(
-                    proof.pA,
-                    proof.pB,
-                    proof.pC,
-                    fixedSizeInputs
-                ),
-                "Invalid proof (batch)"
-            );
-        } else {
-            uint256[] memory publicInputs = constructPublicInputs(
-                nullifiers,
-                outputs,
-                root,
-                INPUT_SIZE_LOCKED,
-                true
-            );
-            // construct the public inputs for verifier
-            uint256[INPUT_SIZE_LOCKED] memory fixedSizeInputs;
-            for (uint256 i = 0; i < fixedSizeInputs.length; i++) {
-                fixedSizeInputs[i] = publicInputs[i];
-            }
-            // Check the proof
-            require(
-                _lockVerifier.verifyProof(
-                    proof.pA,
-                    proof.pB,
-                    proof.pC,
-                    fixedSizeInputs
-                ),
-                "Invalid proof"
-            );
+    function layout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_LOCATION
         }
-        return true;
     }
 }

package/contracts/zeto_anon_nullifier_burnable.sol

@@ -15,35 +15,85 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {Groth16Verifier_BurnNullifier} from "./verifiers/verifier_burn_nullifier.sol";
-import {Groth16Verifier_BurnNullifierBatch} from "./verifiers/verifier_burn_nullifier_batch.sol";
+import {IZetoInitializable} from "./lib/interfaces/IZetoInitializable.sol";
 import {Zeto_AnonNullifier} from "./zeto_anon_nullifier.sol";
-import {ZetoFungibleBurnableWithNullifiers} from "./lib/zeto_fungible_burn_nullifier.sol";
+import {ZetoFungibleBurnableNullifier} from "./lib/zeto_fungible_burn_nullifier.sol";
+import {Commonlib} from "./lib/common/common.sol";
+import {ZetoCommon} from "./lib/zeto_common.sol";
 
-uint256 constant INPUT_SIZE = 4;
-uint256 constant BATCH_INPUT_SIZE = 20;
-
-/// @title A sample implementation of a Zeto based fungible token with anonymity and no encryption
+/// @title A sample implementation of a Zeto based fungible token with
+///        anonymity, history masking via nullifiers, and {burn} support.
 /// @author Kaleido, Inc.
-/// @dev The proof has the following statements:
+/// @notice Decimals: this token uses **4** decimals, inherited from
+///         {ZetoCommon.decimals}. Indexers and UIs reading this contract
+///         directly should treat balances accordingly.
+/// @dev The transfer proof has the following statements:
 ///        - each value in the output commitments must be a positive number in the range 0 ~ (2\*\*40 - 1)
-///        - the sum of the input values match the sum of output values
-///        - the hashes in the input and output match the `hash(value, salt, owner public key)` formula
-///        - the sender possesses the private BabyJubjub key, whose public key is part of the pre-image of the input commitment hashes
+///        - the sum of the nullified values match the sum of output values
+///        - the hashes in the input and output match the hash(value, salt, owner public key) formula
+///        - the sender possesses the private BabyJubjub key, whose public key is part of the pre-image of the input commitment hashes, which match the corresponding nullifiers
+///        - the nullifiers represent input commitments that are included in a Sparse Merkle Tree represented by the root hash
+///
+///      The burn proof has the analogous statements with the output side
+///      collapsed to a single remainder commitment.
+///
+///      Composes {Zeto_AnonNullifier} (transfer + lock lifecycle) with
+///      {ZetoFungibleBurnableNullifier} (burn entry point). Both base
+///      paths converge on the abstract {ZetoCommon.constructPublicInputs}
+///      hook, so this leaf contract must explicitly disambiguate the
+///      override; it simply forwards to {Zeto_AnonNullifier}'s
+///      implementation, which is the same proof layout used for both
+///      unlocked transfers and the locked-input spend flow inherited from
+///      {ZetoFungible}.
+///
+///      Unlike the pre-{ILockableCapability} version, there is no longer a
+///      separate `constructPublicInputsForLock` hook to override; the lock
+///      lifecycle now reuses {constructPublicInputs} with `inputsLocked = true`.
 contract Zeto_AnonNullifierBurnable is
     Zeto_AnonNullifier,
-    ZetoFungibleBurnableWithNullifiers
+    ZetoFungibleBurnableNullifier
 {
+    /// @dev Lock the implementation contract on construction. The parent
+    ///      {Zeto_AnonNullifier} already does this via its own constructor
+    ///      (which Solidity invokes as part of every leaf's deployment),
+    ///      but we restate it here so the H-2 protection survives any
+    ///      future refactor that changes the inheritance graph.
+    ///      `_disableInitializers()` is idempotent, so the duplicate call
+    ///      is a harmless no-op.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
     function initialize(
-        string memory name,
-        string memory symbol,
+        string calldata name,
+        string calldata symbol,
         address initialOwner,
-        VerifiersInfo calldata verifiers
+        IZetoInitializable.VerifiersInfo calldata verifiers
     ) public override initializer {
         __ZetoAnonNullifier_init(name, symbol, initialOwner, verifiers);
-        __ZetoFungibleBurnableWithNullifiers_init(
-            (Groth16Verifier_BurnNullifier)(verifiers.burnVerifier),
-            (Groth16Verifier_BurnNullifierBatch)(verifiers.batchBurnVerifier)
+        __ZetoFungibleBurnableNullifier_init(
+            verifiers.burnVerifier,
+            verifiers.batchBurnVerifier
         );
     }
+
+    function constructPublicInputs(
+        uint256[] memory inputs,
+        uint256[] memory outputs,
+        bytes memory proof,
+        bool inputsLocked
+    )
+        internal
+        override(Zeto_AnonNullifier, ZetoCommon)
+        returns (uint256[] memory, Commonlib.Proof memory)
+    {
+        return
+            Zeto_AnonNullifier.constructPublicInputs(
+                inputs,
+                outputs,
+                proof,
+                inputsLocked
+            );
+    }
 }