@rev-net/core-v6 0.0.35 → 0.0.37

package/test/REVLoansSourced.t.sol

@@ -751,11 +751,11 @@ contract REVLoansSourcedTests is TestBaseWorkflow {
 
         uint256 fullReclaimableSurplus = jbMultiTerminal().STORE()
             .currentReclaimableSurplusOf({
-                projectId: revnetProjectId,
-                cashOutCount: tokensToCashout,
-                totalSupply: totalSupplyExcludingAutoMint,
-                surplus: nativeSurplus
-            });
+            projectId: revnetProjectId,
+            cashOutCount: tokensToCashout,
+            totalSupply: totalSupplyExcludingAutoMint,
+            surplus: nativeSurplus
+        });
 
         assertGe(fullReclaimableSurplus, loanable);
 
@@ -764,11 +764,11 @@ contract REVLoansSourcedTests is TestBaseWorkflow {
 
         uint256 reclaimableSurplus = jbMultiTerminal().STORE()
             .currentReclaimableSurplusOf({
-                projectId: revnetProjectId,
-                cashOutCount: tokensToCashout - feeTokenCount,
-                totalSupply: totalSupplyExcludingAutoMint,
-                surplus: nativeSurplus
-            });
+            projectId: revnetProjectId,
+            cashOutCount: tokensToCashout - feeTokenCount,
+            totalSupply: totalSupplyExcludingAutoMint,
+            surplus: nativeSurplus
+        });
 
         // In the `revFee` calculation we decrease the `nativeSurplus` by the `reclaimableSurplus`
         // but due to a `stack too deep` we can't do that there, so we decrease it here.
@@ -777,11 +777,11 @@ contract REVLoansSourcedTests is TestBaseWorkflow {
 
         uint256 revFee = jbMultiTerminal().STORE()
             .currentReclaimableSurplusOf({
-                projectId: revnetProjectId,
-                cashOutCount: feeTokenCount,
-                totalSupply: totalSupplyExcludingAutoMint - (tokensToCashout - feeTokenCount),
-                surplus: nativeSurplus
-            });
+            projectId: revnetProjectId,
+            cashOutCount: feeTokenCount,
+            totalSupply: totalSupplyExcludingAutoMint - (tokensToCashout - feeTokenCount),
+            surplus: nativeSurplus
+        });
 
         assertGe(fullReclaimableSurplus, mulDiv((reclaimableSurplus + revFee), 995, 1000)); // small marging for curve
         // rounding.

package/test/TestCashOutCallerValidation.t.sol

@@ -315,14 +315,14 @@ contract TestCashOutCallerValidation is TestBaseWorkflow {
         vm.prank(USER);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER,
-                projectId: REVNET_ID,
-                cashOutCount: tokenCount,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER),
-                metadata: ""
-            });
+            holder: USER,
+            projectId: REVNET_ID,
+            cashOutCount: tokenCount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER),
+            metadata: ""
+        });
 
         assertGt(reclaimed, 0, "Should have reclaimed some ETH");
 

package/test/TestConversionDocumentation.t.sol

@@ -286,11 +286,8 @@ contract TestConversionDocumentation is TestBaseWorkflow {
         vm.prank(USER);
         jbController()
             .launchRulesetsFor({
-                projectId: projectId,
-                rulesetConfigurations: rulesetConfigs,
-                terminalConfigurations: termConfigs,
-                memo: ""
-            });
+            projectId: projectId, rulesetConfigurations: rulesetConfigs, terminalConfigurations: termConfigs, memo: ""
+        });
 
         // Now try to convert this project to a revnet — should revert.
         // Approve NFT to REV_DEPLOYER.

package/test/TestCrossCurrencyReclaim.t.sol

@@ -268,14 +268,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: tokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: tokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         assertGt(reclaimed, 0, "should reclaim some ETH");
         // With 50% tax and single holder cashing out everything, the bonding curve returns the full surplus.
@@ -310,14 +310,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimedToken = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: revTokens,
-                tokenToReclaim: address(TOKEN),
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: revTokens,
+            tokenToReclaim: address(TOKEN),
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         assertGt(reclaimedToken, 0, "should reclaim some TOKEN");
         assertLe(reclaimedToken, tokenAmount, "should not exceed total TOKEN paid in");
@@ -358,14 +358,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.expectRevert();
         jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: revTokens,
-                tokenToReclaim: address(TOKEN),
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: revTokens,
+            tokenToReclaim: address(TOKEN),
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
     }
 
     /// @notice Pay with TOKEN (so the surplus is in TOKEN), then pay with ETH too.
@@ -395,14 +395,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimedToken = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: cashOutCount,
-                tokenToReclaim: address(TOKEN),
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: cashOutCount,
+            tokenToReclaim: address(TOKEN),
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         assertGt(reclaimedToken, 0, "should reclaim some TOKEN");
         assertLe(reclaimedToken, tokenPayment, "should not exceed total TOKEN paid in");
@@ -442,14 +442,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: tokens1,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: tokens1,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
         assertGt(reclaimed, 0, "should reclaim ETH from mixed-currency surplus");
 
         // The reclaimed amount should be less than the original payment (due to bonding curve tax).
@@ -480,14 +480,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: tokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: tokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         assertLe(reclaimed, 1, "tiny payment should not yield more than original amount");
     }
@@ -517,14 +517,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: revTokens,
-                tokenToReclaim: address(TOKEN),
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: revTokens,
+            tokenToReclaim: address(TOKEN),
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         // Should reclaim some TOKEN (bounded by the original payment amount).
         assertLe(reclaimed, tokenAmount, "should not exceed original TOKEN payment");
@@ -559,14 +559,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: revTokens,
-                tokenToReclaim: address(TOKEN),
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: revTokens,
+            tokenToReclaim: address(TOKEN),
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         assertLe(reclaimed, tokenAmount, "should not exceed total TOKEN paid");
     }
@@ -595,14 +595,14 @@ contract TestCrossCurrencyReclaim is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: tokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: tokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
 
         // With 0% cash out tax, no fee is charged on cash outs (per REVDeployer.beforeCashOutRecordedWith).
         assertEq(reclaimed, balanceBefore, "0% tax, single holder should reclaim full balance");

package/test/TestLongTailEconomics.t.sol

@@ -363,14 +363,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
             vm.prank(users[i]);
             uint256 reclaimed = jbMultiTerminal()
                 .cashOutTokensOf({
-                    holder: users[i],
-                    projectId: REVNET_ID,
-                    cashOutCount: userTokens[i],
-                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                    minTokensReclaimed: 0,
-                    beneficiary: payable(users[i]),
-                    metadata: ""
-                });
+                holder: users[i],
+                projectId: REVNET_ID,
+                cashOutCount: userTokens[i],
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(users[i]),
+                metadata: ""
+            });
             totalReclaimed += reclaimed;
         }
 
@@ -412,14 +412,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
         vm.prank(payer);
         uint256 reclaimedHalf = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: payer,
-                projectId: REVNET_ID,
-                cashOutCount: halfTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(payer),
-                metadata: ""
-            });
+            holder: payer,
+            projectId: REVNET_ID,
+            cashOutCount: halfTokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(payer),
+            metadata: ""
+        });
 
         // With a 50% tax rate and being the only holder, cashing out half the tokens
         // should return less than half the surplus (bonding curve subproportional behavior).
@@ -452,14 +452,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
                 vm.prank(users[i]);
                 jbMultiTerminal()
                     .cashOutTokensOf({
-                        holder: users[i],
-                        projectId: REVNET_ID,
-                        cashOutCount: userBalance / 2,
-                        tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                        minTokensReclaimed: 0,
-                        beneficiary: payable(users[i]),
-                        metadata: ""
-                    });
+                    holder: users[i],
+                    projectId: REVNET_ID,
+                    cashOutCount: userBalance / 2,
+                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                    minTokensReclaimed: 0,
+                    beneficiary: payable(users[i]),
+                    metadata: ""
+                });
             }
         }
 
@@ -479,14 +479,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
                 vm.prank(users[3]);
                 jbMultiTerminal()
                     .cashOutTokensOf({
-                        holder: users[3],
-                        projectId: REVNET_ID,
-                        cashOutCount: user3Balance,
-                        tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                        minTokensReclaimed: 0,
-                        beneficiary: payable(users[3]),
-                        metadata: ""
-                    });
+                    holder: users[3],
+                    projectId: REVNET_ID,
+                    cashOutCount: user3Balance,
+                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                    minTokensReclaimed: 0,
+                    beneficiary: payable(users[3]),
+                    metadata: ""
+                });
             }
         }
 
@@ -556,14 +556,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
         vm.prank(lateUser);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: lateUser,
-                projectId: REVNET_ID,
-                cashOutCount: lateTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(lateUser),
-                metadata: ""
-            });
+            holder: lateUser,
+            projectId: REVNET_ID,
+            cashOutCount: lateTokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(lateUser),
+            metadata: ""
+        });
 
         // The late entrant should not extract more than they put in.
         assertLe(reclaimed, 10e18, "late entrant should not extract more than they paid");
@@ -599,14 +599,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
                 vm.prank(users[0]);
                 jbMultiTerminal()
                     .cashOutTokensOf({
-                        holder: users[0],
-                        projectId: REVNET_ID,
-                        cashOutCount: balance0 / 3,
-                        tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                        minTokensReclaimed: 0,
-                        beneficiary: payable(users[0]),
-                        metadata: ""
-                    });
+                    holder: users[0],
+                    projectId: REVNET_ID,
+                    cashOutCount: balance0 / 3,
+                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                    minTokensReclaimed: 0,
+                    beneficiary: payable(users[0]),
+                    metadata: ""
+                });
             }
         }
 
@@ -654,14 +654,14 @@ contract TestLongTailEconomics is TestBaseWorkflow {
             vm.prank(user);
             jbMultiTerminal()
                 .cashOutTokensOf({
-                    holder: user,
-                    projectId: REVNET_ID,
-                    cashOutCount: portion,
-                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                    minTokensReclaimed: 0,
-                    beneficiary: payable(user),
-                    metadata: ""
-                });
+                holder: user,
+                projectId: REVNET_ID,
+                cashOutCount: portion,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(user),
+                metadata: ""
+            });
 
             uint256 feeBalanceAfterRound =
                 jbTerminalStore().balanceOf(address(jbMultiTerminal()), FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);

package/test/TestSwapTerminalPermission.t.sol

@@ -206,24 +206,24 @@ contract TestSwapTerminalPermission is TestBaseWorkflow {
     function test_splitOperator_hasRegistryPermissions() public view {
         bool hasBuybackHook = jbPermissions()
             .hasPermission({
-                operator: multisig(),
-                account: address(REV_DEPLOYER),
-                projectId: TEST_REVNET_ID,
-                permissionId: JBPermissionIds.SET_BUYBACK_HOOK,
-                includeRoot: false,
-                includeWildcardProjectId: false
-            });
+            operator: multisig(),
+            account: address(REV_DEPLOYER),
+            projectId: TEST_REVNET_ID,
+            permissionId: JBPermissionIds.SET_BUYBACK_HOOK,
+            includeRoot: false,
+            includeWildcardProjectId: false
+        });
         assertTrue(hasBuybackHook, "Split operator should have SET_BUYBACK_HOOK permission");
 
         bool hasRouterTerminal = jbPermissions()
             .hasPermission({
-                operator: multisig(),
-                account: address(REV_DEPLOYER),
-                projectId: TEST_REVNET_ID,
-                permissionId: JBPermissionIds.SET_ROUTER_TERMINAL,
-                includeRoot: false,
-                includeWildcardProjectId: false
-            });
+            operator: multisig(),
+            account: address(REV_DEPLOYER),
+            projectId: TEST_REVNET_ID,
+            permissionId: JBPermissionIds.SET_ROUTER_TERMINAL,
+            includeRoot: false,
+            includeWildcardProjectId: false
+        });
         assertTrue(hasRouterTerminal, "Split operator should have SET_ROUTER_TERMINAL permission");
     }
 
@@ -244,13 +244,13 @@ contract TestSwapTerminalPermission is TestBaseWorkflow {
         for (uint256 i = 0; i < expectedPermissions.length; i++) {
             bool hasPermission = jbPermissions()
                 .hasPermission({
-                    operator: multisig(),
-                    account: address(REV_DEPLOYER),
-                    projectId: TEST_REVNET_ID,
-                    permissionId: expectedPermissions[i],
-                    includeRoot: false,
-                    includeWildcardProjectId: false
-                });
+                operator: multisig(),
+                account: address(REV_DEPLOYER),
+                projectId: TEST_REVNET_ID,
+                permissionId: expectedPermissions[i],
+                includeRoot: false,
+                includeWildcardProjectId: false
+            });
             assertTrue(
                 hasPermission,
                 string.concat(

package/test/audit/HiddenSupplyCashout.t.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+
+import {TestHiddenTokens} from "../TestHiddenTokens.t.sol";
+
+contract CodexNemesisHiddenSupplyCashoutTest is TestHiddenTokens {
+    function test_hiddenSupplyCanDrainCashoutAndThenBeRevealed() public {
+        uint256 payAmount = 10 ether;
+
+        vm.prank(USER);
+        uint256 minted = jbMultiTerminal().pay{value: payAmount}({
+            projectId: REVNET_ID,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: payAmount,
+            beneficiary: USER,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        uint256 terminalBalanceBefore =
+            jbTerminalStore().balanceOf(address(jbMultiTerminal()), REVNET_ID, JBConstants.NATIVE_TOKEN);
+        assertEq(terminalBalanceBefore, payAmount, "setup: revnet terminal balance");
+
+        _allowHolderToHide(USER, REVNET_ID);
+
+        uint256 hiddenCount = minted / 2;
+        vm.prank(USER);
+        HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hiddenCount, USER);
+
+        uint256 visibleSupply = jbController().TOKENS().totalSupplyOf(REVNET_ID);
+        assertEq(visibleSupply, minted - hiddenCount, "hidden tokens left the cash-out denominator");
+
+        vm.prank(USER);
+        jbMultiTerminal()
+            .cashOutTokensOf({
+            holder: USER,
+            projectId: REVNET_ID,
+            cashOutCount: visibleSupply,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER),
+            metadata: ""
+        });
+
+        uint256 terminalBalanceAfter =
+            jbTerminalStore().balanceOf(address(jbMultiTerminal()), REVNET_ID, JBConstants.NATIVE_TOKEN);
+        assertEq(terminalBalanceAfter, 0, "visible tranche drained the revnet balance");
+
+        vm.prank(USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hiddenCount, USER);
+
+        assertEq(
+            jbController().TOKENS().totalBalanceOf(USER, REVNET_ID),
+            hiddenCount,
+            "hidden tranche was restored after the cash out"
+        );
+    }
+}