@rev-net/core-v6 0.0.36 → 0.0.37

package/RISKS.md

@@ -27,7 +27,7 @@ This file focuses on the staged-economics, runtime-hook, hidden-supply, and loan
 
 - **Stage immutability cuts both ways.** A bad stage schedule or bad cash-out tax choice is expensive to unwind.
 - **Borrowability depends on live economics.** If surplus, supply, or cross-chain state are wrong, loan capacity becomes wrong.
-- **Zero or degraded price feeds can undercount debt.** If a source becomes invisible to debt aggregation, later borrowing can become too permissive.
+- **Zero or degraded price feeds can undercount debt.** If a source becomes invisible to debt aggregation, later borrowing can become too permissive. Specifically, `_debtOf` skips sources where `pricePerUnitOf` returns zero, treating them as if the borrower has no debt in that source. If a feed breaks or returns zero, existing debt in that currency is effectively invisible, inflating the borrower's apparent borrowable amount.
 - **Hidden-token mechanics change visible supply.** That affects per-token cash-out value and can change the economics seen by other holders.
 - **Auto-issuance dilutes holders predictably but still materially.** Timing is permissionless, even if the amounts are fixed at deployment.
 - **Omnichain expansion can corrupt surplus aggregation.** Since borrowability aggregates surplus from all registered terminals across chains, a compromised or misconfigured terminal on a remote chain affects global surplus accounting.
@@ -95,3 +95,13 @@ A project that expands to a new chain can register additional terminals on that
 ### 8.7 REVLoans CEI violation in `_adjust`
 
 In `REVLoans._adjust`, `totalCollateralOf[revnetId]` is incremented after external calls (`useAllowanceOf`, fee payment). A reentrant `borrowFrom` would see a lower `totalCollateralOf`. This is documented inline (lines 1128-1132) and requires an adversarial pay hook on the revnet's own terminal -- a trust-level configuration that is not realistic in standard deployments.
+
+### 8.8 Remote loan corrections not reflected in local borrowability
+
+`_borrowableAmountFrom` adds back local `totalBorrowed` and `totalCollateral` to reconstitute pre-loan economic state for the bonding curve. However, remote chain snapshots (built by `JBSuckerLib.buildSnapshotMessage`) capture raw surplus/supply WITHOUT loan corrections from the remote chain. This is accepted because:
+
+1. Suckers are a general-purpose bridging layer and should not need knowledge of revnet-specific loan mechanics.
+2. The `localSurplus` cap (REVLoans line 386-387) prevents extraction beyond what the local terminal actually holds.
+3. The over-lending exposure is bounded by the difference between corrected and uncorrected remote values, which is proportional to remote outstanding loans — typically a small fraction of total surplus.
+
+Project operators deploying cross-chain revnets with active loan markets on multiple chains should understand that local borrowability calculations do not account for remote outstanding loans.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rev-net/core-v6",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,14 +19,14 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'revnet-core-v6'"
   },
   "dependencies": {
-    "@bananapus/721-hook-v6": "^0.0.35",
-    "@bananapus/buyback-hook-v6": "^0.0.27",
-    "@bananapus/core-v6": "^0.0.34",
-    "@bananapus/ownable-v6": "^0.0.17",
-    "@bananapus/permission-ids-v6": "^0.0.17",
-    "@bananapus/router-terminal-v6": "^0.0.26",
-    "@bananapus/suckers-v6": "^0.0.25",
-    "@croptop/core-v6": "github:mejango/croptop-core-v6",
+    "@bananapus/721-hook-v6": "^0.0.38",
+    "@bananapus/buyback-hook-v6": "^0.0.30",
+    "@bananapus/core-v6": "^0.0.36",
+    "@bananapus/ownable-v6": "^0.0.20",
+    "@bananapus/permission-ids-v6": "^0.0.19",
+    "@bananapus/router-terminal-v6": "^0.0.30",
+    "@bananapus/suckers-v6": "^0.0.28",
+    "@croptop/core-v6": "^0.0.36",
     "@openzeppelin/contracts": "^5.6.1",
     "@uniswap/v4-core": "^1.0.2",
     "@uniswap/v4-periphery": "^1.0.3"

package/src/REVLoans.sol

@@ -627,93 +627,15 @@ contract REVLoans is ERC721, ERC2771Context, JBPermissioned, Ownable, IREVLoans
         // Note: the operator controls `beneficiary`, so they can direct borrowed funds to any address.
         _requirePermissionFrom({account: holder, projectId: revnetId, permissionId: JBPermissionIds.OPEN_LOAN});
 
-        // A loan needs to have collateral.
-        if (collateralCount == 0) revert REVLoans_ZeroCollateralLoanIsInvalid();
-
-        // Make sure the source terminal is registered in the directory for this revnet.
-        if (!DIRECTORY.isTerminalOf({projectId: revnetId, terminal: IJBTerminal(address(source.terminal))})) {
-            revert REVLoans_InvalidTerminal(address(source.terminal), revnetId);
-        }
-
-        // Make sure the prepaid fee percent is between `MIN_PREPAID_FEE_PERCENT` and `MAX_PREPAID_FEE_PERCENT`. Meaning
-        // an 16 year loan can be paid upfront with a
-        // payment of 50% of the borrowed assets, the cheapest possible rate.
-        if (prepaidFeePercent < MIN_PREPAID_FEE_PERCENT || prepaidFeePercent > MAX_PREPAID_FEE_PERCENT) {
-            revert REVLoans_InvalidPrepaidFeePercent(
-                prepaidFeePercent, MIN_PREPAID_FEE_PERCENT, MAX_PREPAID_FEE_PERCENT
-            );
-        }
-
-        // Cache the current ruleset once — used by both _cashOutDelayOf and _borrowAmountFrom.
-        JBRuleset memory currentRuleset = _currentRulesetOf(revnetId);
-
-        // Enforce the cash out delay.
-        {
-            uint256 cashOutDelay = _cashOutDelayOf({revnetId: revnetId, currentRuleset: currentRuleset});
-            if (cashOutDelay > block.timestamp) {
-                revert REVLoans_CashOutDelayNotFinished(cashOutDelay, block.timestamp);
-            }
-        }
-
-        // Prevent the loan number from exceeding the ID namespace for this revnet.
-        if (totalLoansBorrowedFor[revnetId] >= _ONE_TRILLION) revert REVLoans_LoanIdOverflow();
-
-        // Get a reference to the loan ID.
-        loanId = _generateLoanId({revnetId: revnetId, loanNumber: ++totalLoansBorrowedFor[revnetId]});
-
-        // Get a reference to the loan being created.
-        REVLoan storage loan = _loanOf[loanId];
-
-        // Set the loan's values.
-        loan.source = source;
-        loan.createdAt = uint48(block.timestamp);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        loan.prepaidFeePercent = uint16(prepaidFeePercent);
-        loan.prepaidDuration =
-            uint32(mulDiv({x: prepaidFeePercent, y: LOAN_LIQUIDATION_DURATION, denominator: MAX_PREPAID_FEE_PERCENT}));
-
-        // Get the amount of the loan, using the cached ruleset.
-        uint256 borrowAmount = _borrowAmountFrom({
-            loan: loan, revnetId: revnetId, collateralCount: collateralCount, currentRuleset: currentRuleset
-        });
-
-        // Revert if the bonding curve returns zero to prevent creating zero-amount loans.
-        if (borrowAmount == 0) revert REVLoans_ZeroBorrowAmount();
-
-        // Make sure the minimum borrow amount is met.
-        if (borrowAmount < minBorrowAmount) revert REVLoans_UnderMinBorrowAmount(minBorrowAmount, borrowAmount);
-
-        // Get the amount of additional fee to take for the revnet issuing the loan.
-        // Fee rounding may leave a few wei of dust — economically insignificant relative to gas costs.
-        uint256 sourceFeeAmount = JBFees.feeAmountFrom({amountBeforeFee: borrowAmount, feePercent: prepaidFeePercent});
-
-        // Borrow the amount.
-        _adjust({
-            loan: loan,
-            revnetId: revnetId,
-            newBorrowAmount: borrowAmount,
-            newCollateralCount: collateralCount,
-            sourceFeeAmount: sourceFeeAmount,
-            beneficiary: beneficiary,
-            holder: holder
-        });
-
-        // Mint the loan NFT to the holder.
-        _mint({to: holder, tokenId: loanId});
-
-        emit Borrow({
-            loanId: loanId,
+        return _borrowFrom({
             revnetId: revnetId,
-            loan: loan,
             source: source,
-            borrowAmount: borrowAmount,
+            minBorrowAmount: minBorrowAmount,
             collateralCount: collateralCount,
-            sourceFeeAmount: sourceFeeAmount,
             beneficiary: beneficiary,
-            caller: _msgSender()
+            prepaidFeePercent: prepaidFeePercent,
+            holder: holder
         });
-
-        return (loanId, loan);
     }
 
     /// @notice Liquidates loans that have exceeded the 10-year liquidation duration.
@@ -838,7 +760,9 @@ contract REVLoans is ERC721, ERC2771Context, JBPermissioned, Ownable, IREVLoans
 
         // Make a new loan with the leftover collateral from reallocating.
         // The loan owner is the holder for the new loan (their tokens are used as collateral).
-        (newLoanId, newLoan) = borrowFrom({
+        // Uses _borrowFrom to skip the OPEN_LOAN permission check — the caller already proved REALLOCATE_LOAN
+        // permission above, and requiring OPEN_LOAN here would block operators with only REALLOCATE_LOAN.
+        (newLoanId, newLoan) = _borrowFrom({
             revnetId: revnetId,
             source: source,
             minBorrowAmount: minBorrowAmount,
@@ -1234,6 +1158,119 @@ contract REVLoans is ERC721, ERC2771Context, JBPermissioned, Ownable, IREVLoans
         IERC20(token).forceApprove({spender: to, value: 0});
     }
 
+    /// @notice Internal implementation of loan creation, without the OPEN_LOAN permission check.
+    /// @dev Called by `borrowFrom` (after its own permission check) and by `reallocateCollateralFromLoan`
+    /// (which only requires REALLOCATE_LOAN permission).
+    /// @param revnetId The ID of the revnet being borrowed from.
+    /// @param source The source of the loan being borrowed.
+    /// @param minBorrowAmount The minimum amount being borrowed.
+    /// @param collateralCount The amount of tokens to use as collateral for the loan.
+    /// @param beneficiary The address that'll receive the borrowed funds and the tokens resulting from fee payments.
+    /// @param prepaidFeePercent The fee percent that will be charged upfront.
+    /// @param holder The address whose tokens are used as collateral and who receives the loan NFT.
+    /// @return loanId The ID of the loan created from borrowing.
+    /// @return loan The loan created from borrowing.
+    function _borrowFrom(
+        uint256 revnetId,
+        REVLoanSource calldata source,
+        uint256 minBorrowAmount,
+        uint256 collateralCount,
+        address payable beneficiary,
+        uint256 prepaidFeePercent,
+        address holder
+    )
+        internal
+        returns (uint256 loanId, REVLoan memory)
+    {
+        // A loan needs to have collateral.
+        if (collateralCount == 0) revert REVLoans_ZeroCollateralLoanIsInvalid();
+
+        // Make sure the source terminal is registered in the directory for this revnet.
+        if (!DIRECTORY.isTerminalOf({projectId: revnetId, terminal: IJBTerminal(address(source.terminal))})) {
+            revert REVLoans_InvalidTerminal(address(source.terminal), revnetId);
+        }
+
+        // Make sure the prepaid fee percent is between `MIN_PREPAID_FEE_PERCENT` and `MAX_PREPAID_FEE_PERCENT`. Meaning
+        // an 16 year loan can be paid upfront with a
+        // payment of 50% of the borrowed assets, the cheapest possible rate.
+        if (prepaidFeePercent < MIN_PREPAID_FEE_PERCENT || prepaidFeePercent > MAX_PREPAID_FEE_PERCENT) {
+            revert REVLoans_InvalidPrepaidFeePercent(
+                prepaidFeePercent, MIN_PREPAID_FEE_PERCENT, MAX_PREPAID_FEE_PERCENT
+            );
+        }
+
+        // Cache the current ruleset once — used by both _cashOutDelayOf and _borrowAmountFrom.
+        JBRuleset memory currentRuleset = _currentRulesetOf(revnetId);
+
+        // Enforce the cash out delay.
+        {
+            uint256 cashOutDelay = _cashOutDelayOf({revnetId: revnetId, currentRuleset: currentRuleset});
+            if (cashOutDelay > block.timestamp) {
+                revert REVLoans_CashOutDelayNotFinished(cashOutDelay, block.timestamp);
+            }
+        }
+
+        // Prevent the loan number from exceeding the ID namespace for this revnet.
+        if (totalLoansBorrowedFor[revnetId] >= _ONE_TRILLION) revert REVLoans_LoanIdOverflow();
+
+        // Get a reference to the loan ID.
+        loanId = _generateLoanId({revnetId: revnetId, loanNumber: ++totalLoansBorrowedFor[revnetId]});
+
+        // Get a reference to the loan being created.
+        REVLoan storage loan = _loanOf[loanId];
+
+        // Set the loan's values.
+        loan.source = source;
+        loan.createdAt = uint48(block.timestamp);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        loan.prepaidFeePercent = uint16(prepaidFeePercent);
+        loan.prepaidDuration =
+            uint32(mulDiv({x: prepaidFeePercent, y: LOAN_LIQUIDATION_DURATION, denominator: MAX_PREPAID_FEE_PERCENT}));
+
+        // Get the amount of the loan, using the cached ruleset.
+        uint256 borrowAmount = _borrowAmountFrom({
+            loan: loan, revnetId: revnetId, collateralCount: collateralCount, currentRuleset: currentRuleset
+        });
+
+        // Revert if the bonding curve returns zero to prevent creating zero-amount loans.
+        if (borrowAmount == 0) revert REVLoans_ZeroBorrowAmount();
+
+        // Make sure the minimum borrow amount is met.
+        if (borrowAmount < minBorrowAmount) revert REVLoans_UnderMinBorrowAmount(minBorrowAmount, borrowAmount);
+
+        // Get the amount of additional fee to take for the revnet issuing the loan.
+        // Fee rounding may leave a few wei of dust — economically insignificant relative to gas costs.
+        uint256 sourceFeeAmount = JBFees.feeAmountFrom({amountBeforeFee: borrowAmount, feePercent: prepaidFeePercent});
+
+        // Borrow the amount.
+        _adjust({
+            loan: loan,
+            revnetId: revnetId,
+            newBorrowAmount: borrowAmount,
+            newCollateralCount: collateralCount,
+            sourceFeeAmount: sourceFeeAmount,
+            beneficiary: beneficiary,
+            holder: holder
+        });
+
+        // Mint the loan NFT to the holder.
+        _mint({to: holder, tokenId: loanId});
+
+        emit Borrow({
+            loanId: loanId,
+            revnetId: revnetId,
+            loan: loan,
+            source: source,
+            borrowAmount: borrowAmount,
+            collateralCount: collateralCount,
+            sourceFeeAmount: sourceFeeAmount,
+            beneficiary: beneficiary,
+            caller: _msgSender()
+        });
+
+        return (loanId, loan);
+    }
+
     /// @notice Reallocates collateral from a loan by making a new loan based on the original, with reduced collateral.
     /// @param loanId The ID of the loan to reallocate collateral from.
     /// @param revnetId The ID of the revnet the loan is from.

package/src/REVOwner.sol

@@ -178,7 +178,7 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook {
             + SUCKER_REGISTRY.remoteSurplusOf({
                 projectId: context.projectId,
                 decimals: context.surplus.decimals,
-                currency: uint256(uint160(context.surplus.token))
+                currency: uint256(context.surplus.currency)
             });
 
         // If there's no cash out tax (100% cash out tax rate), if there's no fee terminal, or if the beneficiary is
@@ -397,8 +397,8 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook {
             if (context.forwardedAmount.token != JBConstants.NATIVE_TOKEN) {
                 IERC20(context.forwardedAmount.token)
                     .safeDecreaseAllowance({
-                        spender: address(feeTerminal), requestedDecrease: context.forwardedAmount.value
-                    });
+                    spender: address(feeTerminal), requestedDecrease: context.forwardedAmount.value
+                });
             }
 
             // If the fee can't be processed, return the funds to the project.

package/test/REV.integrations.t.sol

@@ -531,25 +531,25 @@ contract REVnet_Integrations is TestBaseWorkflow {
         // The loans contract should have USE_ALLOWANCE permission for any revnet via the wildcard grant.
         bool hasPermission = jbPermissions()
             .hasPermission({
-                operator: address(REV_DEPLOYER.LOANS()),
-                account: address(REV_DEPLOYER),
-                projectId: REVNET_ID,
-                permissionId: JBPermissionIds.USE_ALLOWANCE,
-                includeRoot: false,
-                includeWildcardProjectId: true
-            });
+            operator: address(REV_DEPLOYER.LOANS()),
+            account: address(REV_DEPLOYER),
+            projectId: REVNET_ID,
+            permissionId: JBPermissionIds.USE_ALLOWANCE,
+            includeRoot: false,
+            includeWildcardProjectId: true
+        });
         assertTrue(hasPermission, "LOANS should have USE_ALLOWANCE for deployed revnet");
 
         // Also holds for a revnet that doesn't exist yet — the wildcard covers all projects.
         bool hasPermissionForFuture = jbPermissions()
             .hasPermission({
-                operator: address(REV_DEPLOYER.LOANS()),
-                account: address(REV_DEPLOYER),
-                projectId: 999,
-                permissionId: JBPermissionIds.USE_ALLOWANCE,
-                includeRoot: false,
-                includeWildcardProjectId: true
-            });
+            operator: address(REV_DEPLOYER.LOANS()),
+            account: address(REV_DEPLOYER),
+            projectId: 999,
+            permissionId: JBPermissionIds.USE_ALLOWANCE,
+            includeRoot: false,
+            includeWildcardProjectId: true
+        });
         assertTrue(hasPermissionForFuture, "LOANS should have USE_ALLOWANCE for any project via wildcard");
     }
 

package/test/REVInvincibility.t.sol

@@ -692,14 +692,14 @@ contract REVInvincibility_PropertyTests is TestBaseWorkflow {
         vm.prank(USER);
         try jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER,
-                projectId: REVNET_ID,
-                cashOutCount: tokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER),
-                metadata: ""
-            }) returns (
+            holder: USER,
+            projectId: REVNET_ID,
+            cashOutCount: tokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER),
+            metadata: ""
+        }) returns (
             uint256 reclaimAmount
         ) {
             // The reclaim amount should be bounded by the bonding curve
@@ -944,14 +944,14 @@ contract REVInvincibility_PropertyTests is TestBaseWorkflow {
         vm.prank(USER);
         try jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER,
-                projectId: REVNET_ID,
-                cashOutCount: tokens / 2,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER),
-                metadata: ""
-            }) returns (
+            holder: USER,
+            projectId: REVNET_ID,
+            cashOutCount: tokens / 2,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER),
+            metadata: ""
+        }) returns (
             uint256 reclaimAmount
         ) {
             // The double fee means the fee project gets more than expected

package/test/REVLifecycle.t.sol

@@ -265,14 +265,14 @@ contract REVLifecycle_Local is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: cashOutAmount,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: cashOutAmount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
         assertGt(reclaimed, 0, "should reclaim some ETH");
 
         // Total supply should decrease after cash out
@@ -311,14 +311,14 @@ contract REVLifecycle_Local is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimedStage0 = jbMultiTerminal()
             .cashOutTokensOf({
-                holder: USER1,
-                projectId: REVNET_ID,
-                cashOutCount: halfTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(USER1),
-                metadata: ""
-            });
+            holder: USER1,
+            projectId: REVNET_ID,
+            cashOutCount: halfTokens,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(USER1),
+            metadata: ""
+        });
         assertGt(reclaimedStage0, 0, "should reclaim in stage 0");
 
         // Cash out tax with 50% rate means you get less than proportional share
@@ -344,14 +344,14 @@ contract REVLifecycle_Local 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 50% cash out tax and single holder, reclaiming full supply
         // should return less than full amount (due to tax)
@@ -386,14 +386,14 @@ contract REVLifecycle_Local is TestBaseWorkflow {
         vm.prank(USER1);
         uint256 reclaimed1 = 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: ""
+        });
 
         // Should reclaim proportional share (minus tax)
         assertGt(reclaimed1, 0, "user1 should reclaim some ETH");

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.