@rev-net/core-v6 0.0.33 → 0.0.35

package/test/audit/NemesisOperatorDelegation.t.sol

@@ -148,32 +148,82 @@ contract NemesisOperatorDelegationTest is TestBaseWorkflow {
         );
     }
 
-    function test_revealTokensOperatorCanRedirectHiddenTokens() public {
+    function test_hiddenTokensOperatorCanAllowHolderToHideOwnTokens() public {
         uint256 userTokens = _payUserIntoRevnet(10e18);
         uint256 hiddenCount = userTokens / 2;
 
         _grantPermission(USER, REVNET_ID, address(HIDDEN_TOKENS), JBPermissionIds.BURN_TOKENS);
-        _grantPermission(USER, REVNET_ID, OPERATOR, JBPermissionIds.REVEAL_TOKENS);
+        _allowHolderToHide(USER);
 
         vm.prank(USER);
         HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hiddenCount, USER);
 
-        vm.prank(OPERATOR);
-        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hiddenCount, OPERATOR, USER);
+        vm.prank(USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hiddenCount, USER);
 
         assertEq(HIDDEN_TOKENS.hiddenBalanceOf(USER, REVNET_ID), 0, "holder hidden balance was consumed");
         assertEq(
-            jbController().TOKENS().totalBalanceOf(OPERATOR, REVNET_ID),
-            hiddenCount,
-            "operator receives the holder's revealed tokens"
+            jbController().TOKENS().totalBalanceOf(USER, REVNET_ID),
+            userTokens,
+            "holder gets their own revealed tokens back"
         );
+    }
+
+    function test_hiddenTokensPermissionedOperatorCanHideOwnTokens() public {
+        vm.deal(OPERATOR, 10e18);
+        vm.prank(OPERATOR);
+        uint256 operatorTokens = jbMultiTerminal().pay{value: 10e18}({
+            projectId: REVNET_ID,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 10e18,
+            beneficiary: OPERATOR,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+        uint256 hiddenCount = operatorTokens / 2;
+
+        _grantPermission(OPERATOR, REVNET_ID, address(HIDDEN_TOKENS), JBPermissionIds.BURN_TOKENS);
+        _grantOperatorHidePermission(OPERATOR);
+
+        vm.prank(OPERATOR);
+        HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hiddenCount, OPERATOR);
+
+        assertEq(HIDDEN_TOKENS.hiddenBalanceOf(OPERATOR, REVNET_ID), hiddenCount, "operator hidden balance was updated");
         assertEq(
-            jbController().TOKENS().totalBalanceOf(USER, REVNET_ID),
-            userTokens - hiddenCount,
-            "holder does not get the revealed tokens back"
+            jbController().TOKENS().totalBalanceOf(OPERATOR, REVNET_ID),
+            operatorTokens - hiddenCount,
+            "operator's visible balance was reduced"
         );
     }
 
+    function test_hiddenTokensDelegateCannotHideAnotherHoldersTokens() public {
+        uint256 userTokens = _payUserIntoRevnet(10e18);
+
+        _grantPermission(USER, REVNET_ID, address(HIDDEN_TOKENS), JBPermissionIds.BURN_TOKENS);
+        _allowHolderToHide(USER);
+
+        vm.prank(OPERATOR);
+        vm.expectRevert(
+            abi.encodeWithSelector(REVHiddenTokens.REVHiddenTokens_Unauthorized.selector, REVNET_ID, OPERATOR)
+        );
+        HIDDEN_TOKENS.hideTokensOf(REVNET_ID, userTokens / 2, USER);
+    }
+
+    function test_hiddenTokensOperatorCanDisallowHolder() public {
+        uint256 userTokens = _payUserIntoRevnet(10e18);
+
+        _grantPermission(USER, REVNET_ID, address(HIDDEN_TOKENS), JBPermissionIds.BURN_TOKENS);
+        _allowHolderToHide(USER);
+
+        vm.prank(address(REV_DEPLOYER));
+        HIDDEN_TOKENS.setTokenHidingAllowedFor(REVNET_ID, USER, false);
+
+        vm.prank(USER);
+        vm.expectRevert(abi.encodeWithSelector(REVHiddenTokens.REVHiddenTokens_Unauthorized.selector, REVNET_ID, USER));
+        HIDDEN_TOKENS.hideTokensOf(REVNET_ID, userTokens / 2, USER);
+    }
+
     function _grantPermission(address account, uint256 revnetId, address operator, uint8 permissionId) internal {
         uint8[] memory permissionIds = new uint8[](1);
         permissionIds[0] = permissionId;
@@ -200,6 +250,23 @@ contract NemesisOperatorDelegationTest is TestBaseWorkflow {
         assertGt(tokenCount, 0, "payment should mint revnet tokens");
     }
 
+    function _allowHolderToHide(address holder) internal {
+        vm.prank(address(REV_DEPLOYER));
+        HIDDEN_TOKENS.setTokenHidingAllowedFor(REVNET_ID, holder, true);
+    }
+
+    function _grantOperatorHidePermission(address operator) internal {
+        uint8[] memory permissionIds = new uint8[](1);
+        permissionIds[0] = JBPermissionIds.HIDE_TOKENS;
+
+        vm.prank(address(REV_DEPLOYER));
+        jbPermissions()
+            .setPermissionsFor(
+                address(REV_DEPLOYER),
+                JBPermissionsData({operator: operator, projectId: uint56(REVNET_ID), permissionIds: permissionIds})
+            );
+    }
+
     function _deployFeeProject() internal {
         JBAccountingContext[] memory acc = new JBAccountingContext[](1);
         acc[0] = JBAccountingContext({