Proof verification guardians

.github/workflows/test.yml

@@ -68,7 +68,35 @@ jobs:
 
       - name: Run Forge tests
         run: |
-          forge test -vvv
+          forge test -vvv --no-match-contract MPCOperatorManagerTest
+        id: test
+  test-mpc:
+    name: Foundry Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - uses: actions/cache@v3
+        with:
+          path: "~/.foundry/cache/rpc"
+          key: "${{ runner.os }}-rpc-cache-v1"
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: nightly
+
+      - name: Run Forge build
+        run: |
+          forge --version
+          forge build --sizes
+        id: build
+
+      - name: Run Forge tests
+        run: |
+          forge test -vvv --match-contract MPCOperatorManagerTest --mt ".*MPC"
         id: test
   coverage:
     name: Foundry Coverage

script/scripts/DeployZkBobPoolModules.s.sol

@@ -64,8 +64,12 @@ contract DeployZkBobPoolModules is Script, Test {
         vm.startBroadcast();
 
         ZkBobPoolUSDC impl = new ZkBobPoolUSDC(
-            pool.pool_id(), pool.token(), pool.transfer_verifier(), pool.tree_verifier(),
-            pool.batch_deposit_verifier(), address(pool.direct_deposit_queue())
+            pool.pool_id(),
+            pool.token(),
+            pool.transfer_verifier(),
+            pool.tree_verifier(),
+            pool.batch_deposit_verifier(),
+            address(pool.direct_deposit_queue())
         );
         Migrator mig = new Migrator();
         ZkBobAccounting acc = new ZkBobAccounting(address(pool), 1_000_000_000);

script/scripts/Env.s.sol

@@ -25,17 +25,17 @@ bytes32 constant bobSalt = bytes32(uint256(285834900769));
 // zkbob
 uint256 constant zkBobPoolId = 0; // 0 is reserved for Polygon MVP pool, do not use for other deployments
 PoolType constant zkBobPoolType = PoolType.BOB;
-string constant zkBobVerifiers = "prodV1";
+string constant zkBobVerifiers = "prodV2";
 address constant zkBobToken = 0xB0B195aEFA3650A6908f15CdaC7D92F8a5791B0B;
 uint256 constant zkBobInitialRoot = 11469701942666298368112882412133877458305516134926649826543144744382391691533;
 address constant zkBobRelayer = 0xc2c4AD59B78F4A0aFD0CDB8133E640Db08Fa5b90;
 address constant zkBobRelayerFeeReceiver = 0x758768EC473279c4B1Aa61FA5450745340D4B17d;
 string constant zkBobRelayerURL = "https://relayer-mvp.zkbob.com";
-uint256 constant zkBobPoolCap = 1_000_000 ether;
-uint256 constant zkBobDailyDepositCap = 100_000 ether;
-uint256 constant zkBobDailyWithdrawalCap = 100_000 ether;
-uint256 constant zkBobDailyUserDepositCap = 10_000 ether;
-uint256 constant zkBobDepositCap = 10_000 ether;
+uint256 constant zkBobPoolCap = 1_000_000 gwei;
+uint256 constant zkBobDailyDepositCap = 100_000 gwei;
+uint256 constant zkBobDailyWithdrawalCap = 100_000 gwei;
+uint256 constant zkBobDailyUserDepositCap = 10_000 gwei;
+uint256 constant zkBobDepositCap = 10_000 gwei;
 uint256 constant zkBobDailyUserDirectDepositCap = 0;
 uint256 constant zkBobDirectDepositCap = 0;
 uint256 constant zkBobDirectDepositFee = 0.1 gwei;

script/scripts/Local.s.sol

@@ -45,12 +45,7 @@ contract DeployLocal is Script {
         EIP1967Proxy queueProxy = new EIP1967Proxy(tx.origin, mockImpl, "");
 
         ZkBobPoolBOB poolImpl = new ZkBobPoolBOB(
-            zkBobPoolId,
-            address(bob),
-            transferVerifier,
-            treeVerifier,
-            batchDepositVerifier,
-            address(queueProxy)
+            zkBobPoolId, address(bob), transferVerifier, treeVerifier, batchDepositVerifier, address(queueProxy)
         );
         {
             bytes memory initData = abi.encodeWithSelector(ZkBobPool.initialize.selector, zkBobInitialRoot);

script/scripts/LocalMPC.s.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: CC0-1.0
+
+pragma solidity 0.8.15;
+
+import "forge-std/Script.sol";
+import "./Env.s.sol";
+import "../../test/shared/EIP2470.t.sol";
+import "../../src/BobToken.sol";
+import "../../src/proxy/EIP1967Proxy.sol";
+import "../../src/zkbob/ZkBobPoolBOB.sol";
+import "../../src/zkbob/manager/MutableOperatorManager.sol";
+import "../../src/zkbob/manager/MPCGuard.sol";
+import "../../src/zkbob/ZkBobDirectDepositQueue.sol";
+import "../../src/zkbob/utils/ZkBobAccounting.sol";
+
+contract DeployLocal is Script {
+    function run() external {
+        vm.startBroadcast();
+
+        EIP1967Proxy bobProxy = new EIP1967Proxy(tx.origin, mockImpl, "");
+        BobToken bobImpl = new BobToken(address(bobProxy));
+        bobProxy.upgradeTo(address(bobImpl));
+        BobToken bob = BobToken(address(bobProxy));
+
+        if (bobMinter != address(0)) {
+            bob.updateMinter(bobMinter, true, true);
+        }
+
+        ITransferVerifier transferVerifier;
+        ITreeVerifier treeVerifier;
+        IBatchDepositVerifier batchDepositVerifier;
+        bytes memory code1 =
+            vm.getCode(string.concat("out/", zkBobVerifiers, "/TransferVerifier.sol/TransferVerifier.json"));
+        bytes memory code2 =
+            vm.getCode(string.concat("out/", zkBobVerifiers, "/TreeUpdateVerifier.sol/TreeUpdateVerifier.json"));
+        bytes memory code3 = vm.getCode(
+            string.concat("out/", zkBobVerifiers, "/DelegatedDepositVerifier.sol/DelegatedDepositVerifier.json")
+        );
+        assembly {
+            transferVerifier := create(0, add(code1, 0x20), mload(code1))
+            treeVerifier := create(0, add(code2, 0x20), mload(code2))
+            batchDepositVerifier := create(0, add(code3, 0x20), mload(code3))
+        }
+
+        EIP1967Proxy poolProxy = new EIP1967Proxy(tx.origin, mockImpl, "");
+        EIP1967Proxy queueProxy = new EIP1967Proxy(tx.origin, mockImpl, "");
+
+        ZkBobPoolBOB poolImpl = new ZkBobPoolBOB(
+            zkBobPoolId, address(bob), transferVerifier, treeVerifier, batchDepositVerifier, address(queueProxy)
+        );
+        {
+            bytes memory initData = abi.encodeWithSelector(ZkBobPool.initialize.selector, zkBobInitialRoot);
+            poolProxy.upgradeToAndCall(address(poolImpl), initData);
+        }
+        ZkBobPoolBOB pool = ZkBobPoolBOB(address(poolProxy));
+
+        ZkBobDirectDepositQueue queueImpl = new ZkBobDirectDepositQueue(address(pool), address(bob), 1_000_000_000);
+        queueProxy.upgradeTo(address(queueImpl));
+        ZkBobDirectDepositQueue queue = ZkBobDirectDepositQueue(address(queueProxy));
+
+        {
+            ZkBobAccounting accounting = new ZkBobAccounting(address(pool), 1_000_000_000);
+            accounting.setLimits(
+                0,
+                zkBobPoolCap,
+                zkBobDailyDepositCap,
+                zkBobDailyWithdrawalCap,
+                zkBobDailyUserDepositCap,
+                zkBobDepositCap,
+                zkBobDailyUserDirectDepositCap,
+                zkBobDirectDepositCap
+            );
+            pool.setAccounting(accounting);
+        }
+
+        {
+            MPCGuard guard = new MPCGuard(zkBobRelayer, address(pool));
+            address[] memory guardians = new address[](2);
+            guardians[0] = address(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+            guardians[1] = address(0x70997970C51812dc3A010C7d01b50e0d17dc79C8);
+            IOperatorManager operatorManager =
+                new MutableOperatorManager(address(guard), zkBobRelayerFeeReceiver, zkBobRelayerURL);
+            pool.setOperatorManager(operatorManager);
+            queue.setOperatorManager(operatorManager);
+            queue.setDirectDepositFee(uint64(zkBobDirectDepositFee));
+            queue.setDirectDepositTimeout(uint40(zkBobDirectDepositTimeout));
+            console2.log("MPCGuard:", address(guard));
+        }
+
+        {
+            if (owner != address(0)) {
+                bob.transferOwnership(owner);
+                pool.transferOwnership(owner);
+                queue.transferOwnership(owner);
+            }
+
+            if (admin != tx.origin) {
+                bobProxy.setAdmin(admin);
+                poolProxy.setAdmin(admin);
+                queueProxy.setAdmin(admin);
+            }
+        }
+
+        vm.stopBroadcast();
+
+        require(bobProxy.implementation() == address(bobImpl), "Invalid implementation address");
+        require(bobProxy.admin() == admin, "Proxy admin is not configured");
+        require(bob.owner() == owner, "Owner is not configured");
+        require(bobMinter == address(0) || bob.isMinter(bobMinter), "Bob minter is not configured");
+        require(poolProxy.implementation() == address(poolImpl), "Invalid implementation address");
+        require(poolProxy.admin() == admin, "Proxy admin is not configured");
+        require(pool.owner() == owner, "Owner is not configured");
+        require(pool.transfer_verifier() == transferVerifier, "Transfer verifier is not configured");
+        require(pool.tree_verifier() == treeVerifier, "Tree verifier is not configured");
+
+        console2.log("BobToken:", address(bob));
+        console2.log("BobToken implementation:", address(bobImpl));
+        console2.log("ZkBobPool:", address(pool));
+        console2.log("ZkBobPool implementation:", address(poolImpl));
+        console2.log("ZkBobDirectDepositQueue:", address(queue));
+        console2.log("ZkBobDirectDepositQueue implementation:", address(queueImpl));
+    }
+}

script/scripts/ZkBobPool.s.sol

@@ -53,27 +53,31 @@ contract DeployZkBobPool is Script {
 
         if (zkBobPoolType == PoolType.ETH) {
             vars.poolImpl = new ZkBobPoolETH(
-                zkBobPoolId, zkBobToken,
-                transferVerifier, treeVerifier, batchDepositVerifier,
-                address(vars.queueProxy), permit2
+                zkBobPoolId,
+                zkBobToken,
+                transferVerifier,
+                treeVerifier,
+                batchDepositVerifier,
+                address(vars.queueProxy),
+                permit2
             );
         } else if (zkBobPoolType == PoolType.BOB) {
             vars.poolImpl = new ZkBobPoolBOB(
-                zkBobPoolId, zkBobToken,
-                transferVerifier, treeVerifier, batchDepositVerifier,
-                address(vars.queueProxy)
+                zkBobPoolId, zkBobToken, transferVerifier, treeVerifier, batchDepositVerifier, address(vars.queueProxy)
             );
         } else if (zkBobPoolType == PoolType.USDC) {
             vars.poolImpl = new ZkBobPoolUSDC(
-                zkBobPoolId, zkBobToken,
-                transferVerifier, treeVerifier, batchDepositVerifier,
-                address(vars.queueProxy)
+                zkBobPoolId, zkBobToken, transferVerifier, treeVerifier, batchDepositVerifier, address(vars.queueProxy)
             );
         } else if (zkBobPoolType == PoolType.ERC20) {
             vars.poolImpl = new ZkBobPoolERC20(
-                zkBobPoolId, zkBobToken,
-                transferVerifier, treeVerifier, batchDepositVerifier,
-                address(vars.queueProxy), permit2,
+                zkBobPoolId,
+                zkBobToken,
+                transferVerifier,
+                treeVerifier,
+                batchDepositVerifier,
+                address(vars.queueProxy),
+                permit2,
                 vars.denominator
             );
         } else {

src/interfaces/IOperatorManager.sol

@@ -3,6 +3,8 @@
 pragma solidity 0.8.15;
 
 interface IOperatorManager {
+    function operator() external returns (address);
+
     function isOperator(address _addr) external view returns (bool);
 
     function isOperatorFeeReceiver(address _operator, address _addr) external view returns (bool);

src/interfaces/IZkBobPool.sol

@@ -12,4 +12,13 @@ interface IZkBobPool {
     function accounting() external view returns (IZkBobAccounting);
 
     function recordDirectDeposit(address _sender, uint256 _amount) external;
+
+    function appendDirectDeposits(
+        uint256 _root_after,
+        uint256[] calldata _indices,
+        uint256 _out_commit,
+        uint256[8] memory _batch_deposit_proof,
+        uint256[8] memory _tree_proof
+    )
+        external;
 }