@lfdecentralizedtrust/zeto-contracts 0.5.0 → 0.5.1

package/README.md

@@ -13,6 +13,10 @@ Privacy-preserving token implementations for fungible and non-fungible assets, b
 
   Hardhat and related tooling are pulled in via `@nomicfoundation/hardhat-toolbox`; you do not need to run `hardhat init` in this repository.
 
+### Contract size (EIP-170)
+
+Mainnet limits deployed bytecode to **24,576 bytes**. This repo enforces that on the Hardhat network and at compile time via `hardhat-contract-sizer`. Run `npm run size` to print sizes after compile.
+
 ### Circuits and proving keys
 
 Hardhat tests load circuit WASM via **`zeto-js`** (`file:../zkp/js`). Before running tests:
@@ -74,6 +78,8 @@ npx hardhat run scripts/deploy_cloneable.ts
 
 This deploys the **implementation only**. Leaf tokens lock the impl with `_disableInitializers()`; **`initialize` runs on proxies** created by **`ZetoTokenFactory`**. Tests use **`USE_FACTORY=true`** in `test/lib/deploy.ts` to register the impl and deploy initialized clones. Running the script **by itself** does not yield a ready-to-use initialized token unless you finish that factory flow.
 
+Every token implementation links the external **`ZetoLockableLib`** library (deployed once per chain via Ignition). Token deploy scripts in `scripts/tokens/` pass it in the `libraries` map alongside `SmtLib` / Poseidon where applicable.
+
 For a single initialized deployment without the factory path, use **`deploy_upgradeable.ts`**.
 
 Cheap repeat deployments: OpenZeppelin [minimal proxies / Clones](https://docs.openzeppelin.com/contracts/5.x/api/utils#Clones).

package/config/eip170.ts

@@ -0,0 +1,30 @@
+/**
+ * EIP-170 (Spurious Dragon) maximum deployed runtime bytecode size.
+ * @see https://eips.ethereum.org/EIPS/eip-170
+ */
+export const EIP170_BYTE_LIMIT = 24_576;
+
+/**
+ * Contracts that currently exceed EIP170_BYTE_LIMIT with the compiler settings
+ * in hardhat.config.ts. Exempt from `hardhat-contract-sizer` strict checks
+ * until further library splits land.
+ *
+ * Remove names from this list as implementations are brought under the limit.
+ */
+export const EIP170_EXEMPT_CONTRACTS: readonly string[] = [
+  "Zeto_AnonEncNullifier",
+  "Zeto_AnonEncNullifierKyc",
+  "Zeto_AnonEncNullifierNonRepudiation",
+  "Zeto_AnonNullifierBurnable",
+  "Zeto_AnonNullifierQurrency",
+  "Groth16Verifier_AnonEncNullifierNonRepudiationBatch",
+] as const;
+
+export const EIP170_EXEMPT_CONTRACTS_SET = new Set<string>(
+  EIP170_EXEMPT_CONTRACTS,
+);
+
+/** Token implementations in the exemption list (excludes standalone verifiers). */
+export const EIP170_EXEMPT_TOKEN_SET = new Set<string>(
+  EIP170_EXEMPT_CONTRACTS.filter((name) => name.startsWith("Zeto_")),
+);

package/contracts/lib/interfaces/IZetoLockHooks.sol

@@ -0,0 +1,42 @@
+// Copyright © 2025 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+pragma solidity ^0.8.27;
+
+import {IZetoLockableCapability} from "./IZetoLockableCapability.sol";
+
+/**
+ * @title IZetoLockHooks
+ * @dev Callback surface invoked by {ZetoLockableLib} (via `address(this)`)
+ *      so circuit-specific lock transitions stay in the embedding token
+ *      while shared lock lifecycle logic lives in the external library.
+ */
+interface IZetoLockHooks {
+    /// @dev Thrown when a hook is invoked by an address other than `address(this)`.
+    error NotSelf(address caller);
+
+    function zetoLockDoLockTransition(
+        IZetoLockableCapability.ZetoCreateLockArgs calldata args
+    ) external;
+
+    function zetoLockTransferLocked(
+        bytes32 lockId,
+        uint256[] calldata lockedInputs,
+        uint256[] calldata lockedOutputs,
+        uint256[] calldata outputs,
+        bytes calldata proof,
+        bytes calldata data
+    ) external;
+}

package/contracts/lib/zeto_fungible.sol

@@ -30,9 +30,9 @@ import {IZetoStorage} from "./interfaces/IZetoStorage.sol";
 /// @dev Adds the ERC20-backed deposit/withdraw lifecycle and a multi-input
 ///      {transfer} flow on top of the lock-aware {ZetoLockable} base.
 ///
-///      The lock-lifecycle plumbing (state, modifiers, external entry
-///      points, views) lives in {ZetoLockable}; this contract supplies
-///      only the two ZK-circuit-shaped hooks
+///      The lock-lifecycle plumbing (state, external entry points, views)
+///      lives in the linked external {ZetoLockableLib}; this contract
+///      supplies only the two ZK-circuit-shaped hooks
 ///      ({_doLockTransition} and {_transferLocked}) that pad
 ///      inputs/outputs to the next supported batch size before
 ///      {constructPublicInputs}.
@@ -162,7 +162,7 @@ abstract contract ZetoFungible is ZetoLockable, ReentrancyGuardUpgradeable {
     // ------------------------------------------------------------------
 
     function _doLockTransition(
-        ZetoCreateLockArgs memory args
+        ZetoCreateLockArgs calldata args
     ) internal override {
         validateTransactionProposal(
             args.inputs,
@@ -206,19 +206,15 @@ abstract contract ZetoFungible is ZetoLockable, ReentrancyGuardUpgradeable {
 
         processInputsAndOutputs(paddedInputs, args.outputs, false);
         processLockedOutputs(args.lockedOutputs);
-        // The freshly-locked outputs all start under the lock creator
-        // as both owner and spender; record that on the per-UTXO
-        // projection so {locked} can report it without a reverse lookup.
-        _setLockDelegates(args.lockedOutputs, msg.sender);
     }
 
     function _transferLocked(
         bytes32 /* lockId */,
-        uint256[] memory lockedInputs,
-        uint256[] memory lockedOutputs,
-        uint256[] memory outputs,
-        bytes memory proof,
-        bytes memory /* data */
+        uint256[] calldata lockedInputs,
+        uint256[] calldata lockedOutputs,
+        uint256[] calldata outputs,
+        bytes calldata proof,
+        bytes calldata /* data */
     ) internal override {
         validateTransactionProposal(
             lockedInputs,
@@ -253,10 +249,6 @@ abstract contract ZetoFungible is ZetoLockable, ReentrancyGuardUpgradeable {
         verifyProof(proofStruct, publicInputs, isBatch, true);
         processInputsAndOutputs(paddedInputs, paddedOutputs, true);
         processLockedOutputs(lockedOutputs);
-        // Any newly-locked outputs produced by this spend default to the
-        // current spender as their delegate. (When `lockedOutputs` is
-        // empty -- the common case -- this is a no-op.)
-        _setLockDelegates(lockedOutputs, msg.sender);
     }
 
     /**