@rev-net/core-v6 0.0.36 → 0.0.37

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"
+        );
+    }
+}

package/test/audit/NemesisVerification.t.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBCashOuts} from "@bananapus/core-v6/src/libraries/JBCashOuts.sol";
+
+contract CodexNemesisVerificationTest is Test {
+    function testConfigurationHashDoesNotCommitSplitOperatorSplitsOrExtraMetadata() public pure {
+        bytes32 hashA = _revDeployerEncodedConfigurationHash();
+        bytes32 hashB = _revDeployerEncodedConfigurationHash();
+
+        assertEq(hashA, hashB, "actual REVDeployer hash collides");
+
+        bytes32 fullCommitmentA = keccak256(
+            abi.encode(hashA, address(0x1111), uint32(7000), address(0xAAAA), uint48(30 days), uint16(0x0004))
+        );
+        bytes32 fullCommitmentB = keccak256(
+            abi.encode(hashB, address(0x2222), uint32(7000), address(0xBBBB), uint48(90 days), uint16(0x0000))
+        );
+
+        assertNotEq(fullCommitmentA, fullCommitmentB, "omitted fields are economically distinct");
+    }
+
+    function testRemoteLoanStateOmissionOverstatesCrossChainCashOutValue() public pure {
+        uint256 localSupply = 100 ether;
+        uint256 localSurplus = 100 ether;
+        uint256 remoteVisibleSupply = 1 ether;
+        uint256 remoteVisibleSurplus = 1 ether;
+        uint256 omittedRemoteLoanCollateral = 99 ether;
+        uint256 omittedRemoteLoanDebt = 99 ether;
+        uint256 cashOutCount = 100 ether;
+        uint256 cashOutTaxRate = 1000;
+
+        uint256 current = JBCashOuts.cashOutFrom({
+            surplus: localSurplus + remoteVisibleSurplus,
+            cashOutCount: cashOutCount,
+            totalSupply: localSupply + remoteVisibleSupply,
+            cashOutTaxRate: cashOutTaxRate
+        });
+
+        uint256 withRemoteLoans = JBCashOuts.cashOutFrom({
+            surplus: localSurplus + remoteVisibleSurplus + omittedRemoteLoanDebt,
+            cashOutCount: cashOutCount,
+            totalSupply: localSupply + remoteVisibleSupply + omittedRemoteLoanCollateral,
+            cashOutTaxRate: cashOutTaxRate
+        });
+
+        assertGt(current, withRemoteLoans, "omitting remote loan state should not increase cash-out value");
+        assertGt(current - withRemoteLoans, 4 ether, "drift is material");
+    }
+
+    function testRemoteLoanStateOmissionCanHitFullSupplyBranch() public pure {
+        uint256 localSupply = 100 ether;
+        uint256 localSurplus = 100 ether;
+        uint256 omittedRemoteLoanCollateral = 100 ether;
+        uint256 omittedRemoteLoanDebt = 100 ether;
+        uint256 cashOutCount = 100 ether;
+        uint256 cashOutTaxRate = 1000;
+
+        uint256 current = JBCashOuts.cashOutFrom({
+            surplus: localSurplus, cashOutCount: cashOutCount, totalSupply: localSupply, cashOutTaxRate: cashOutTaxRate
+        });
+
+        uint256 withRemoteLoans = JBCashOuts.cashOutFrom({
+            surplus: localSurplus + omittedRemoteLoanDebt,
+            cashOutCount: cashOutCount,
+            totalSupply: localSupply + omittedRemoteLoanCollateral,
+            cashOutTaxRate: cashOutTaxRate
+        });
+
+        assertEq(current, localSurplus, "current path enters full-supply branch");
+        assertEq(withRemoteLoans, 95 ether, "true omnichain curve should remain partial");
+        assertGt(current, withRemoteLoans, "full-supply branch overstates cash-out value");
+    }
+
+    function _revDeployerEncodedConfigurationHash() internal pure returns (bytes32) {
+        bytes memory encodedConfiguration = abi.encode(uint32(1), "REV", "REV", bytes32("codex-nemesis"));
+
+        encodedConfiguration = abi.encode(encodedConfiguration, address(0x1234));
+
+        encodedConfiguration = abi.encode(
+            encodedConfiguration,
+            uint48(1_740_089_444),
+            uint16(7000),
+            uint112(1_000_000 ether),
+            uint32(30 days),
+            uint32(0),
+            uint16(JBConstants.MAX_CASH_OUT_TAX_RATE / 2)
+        );
+
+        encodedConfiguration = abi.encode(encodedConfiguration, uint32(1), address(0xBEEF), uint104(100_000 ether));
+
+        return keccak256(encodedConfiguration);
+    }
+}