@rev-net/core-v6 0.0.11 → 0.0.13

package/src/REVDeployer.sol

@@ -1,12 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.26;
 
-import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-import {mulDiv} from "@prb/math/src/Common.sol";
 import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
 import {IJB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookDeployer.sol";
 import {JB721TiersHookFlags} from "@bananapus/721-hook-v6/src/structs/JB721TiersHookFlags.sol";
@@ -15,13 +9,11 @@ import {IJBBuybackHookRegistry} from "@bananapus/buyback-hook-v6/src/interfaces/
 import {IJBCashOutHook} from "@bananapus/core-v6/src/interfaces/IJBCashOutHook.sol";
 import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
 import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
-import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.sol";
 import {IJBPermissioned} from "@bananapus/core-v6/src/interfaces/IJBPermissioned.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IJBRulesetApprovalHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
 import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
-import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
 import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
 import {JBCashOuts} from "@bananapus/core-v6/src/libraries/JBCashOuts.sol";
 import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
@@ -38,14 +30,18 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
 import {JBRulesetConfig} from "@bananapus/core-v6/src/structs/JBRulesetConfig.sol";
 import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
-import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
-import {JBTokenAmount} from "@bananapus/core-v6/src/structs/JBTokenAmount.sol";
 import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
 import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
 import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
 import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
 import {CTPublisher} from "@croptop/core-v6/src/CTPublisher.sol";
 import {CTAllowedPost} from "@croptop/core-v6/src/structs/CTAllowedPost.sol";
+import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
 
 import {IREVDeployer} from "./interfaces/IREVDeployer.sol";
 import {REVAutoIssuance} from "./structs/REVAutoIssuance.sol";
@@ -224,6 +220,8 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         });
 
         // Give the loan contract permission to use the surplus allowance of all revnets.
+        // Uses wildcard revnetId=0 intentionally — the loan contract is a singleton shared by all revnets,
+        // and each revnet's surplus allowance limits already constrain how much can be drawn.
         _setPermission({operator: LOANS, revnetId: 0, permissionId: JBPermissionIds.USE_ALLOWANCE});
 
         // Give the buyback hook (registry) permission to configure pools on all revnets.
@@ -255,6 +253,8 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         )
     {
         // If the cash out is from a sucker, return the full cash out amount without taxes or fees.
+        // This relies on the sucker registry to only contain trusted sucker contracts deployed via
+        // the registry's own deploySuckersFor flow — external addresses cannot register as suckers.
         if (_isSuckerOf({revnetId: context.projectId, addr: context.holder})) {
             return (0, context.cashOutCount, context.totalSupply, hookSpecifications);
         }
@@ -270,13 +270,16 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         // Get the terminal that will receive the cash out fee.
         IJBTerminal feeTerminal = DIRECTORY.primaryTerminalOf({projectId: FEE_REVNET_ID, token: context.surplus.token});
 
-        // If there's no cash out tax (100% cash out tax rate), or if there's no fee terminal, do not charge a fee.
-        if (context.cashOutTaxRate == 0 || address(feeTerminal) == address(0)) {
+        // If there's no cash out tax (100% cash out tax rate), if there's no fee terminal, or if the beneficiary is
+        // feeless (e.g. the router terminal routing value between projects), do not charge a fee.
+        if (context.cashOutTaxRate == 0 || address(feeTerminal) == address(0) || context.beneficiaryIsFeeless) {
             return (context.cashOutTaxRate, context.cashOutCount, context.totalSupply, hookSpecifications);
         }
 
         // Get a reference to the number of tokens being used to pay the fee (out of the total being cashed out).
-        uint256 feeCashOutCount = mulDiv(context.cashOutCount, FEE, JBConstants.MAX_FEE);
+        // Micro cash outs (< 40 wei at 2.5% fee) round feeCashOutCount to zero, bypassing the fee.
+        // Economically insignificant: the gas cost of the transaction far exceeds the bypassed fee. No fix needed.
+        uint256 feeCashOutCount = mulDiv({x: context.cashOutCount, y: FEE, denominator: JBConstants.MAX_FEE});
         uint256 nonFeeCashOutCount = context.cashOutCount - feeCashOutCount;
 
         // Keep a reference to the amount claimable with non-fee tokens.
@@ -353,7 +356,7 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         if (projectAmount == 0) {
             weight = 0;
         } else if (projectAmount < context.amount.value) {
-            weight = mulDiv(weight, projectAmount, context.amount.value);
+            weight = mulDiv({x: weight, y: projectAmount, denominator: context.amount.value});
         }
 
         // Merge hook specifications: 721 hook spec first, then buyback hook spec.
@@ -483,26 +486,6 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         }
     }
 
-    /// @notice Try to initialize a Uniswap V4 buyback pool for a terminal token at a generic 1:1 price.
-    /// @dev Called after the ERC-20 token is deployed so the pool can be initialized in the PoolManager.
-    /// Silently catches failures (e.g., if the pool is already initialized).
-    /// @param revnetId The ID of the revnet.
-    /// @param terminalToken The terminal token to initialize a buyback pool for.
-    function _tryInitializeBuybackPoolFor(uint256 revnetId, address terminalToken) internal {
-        // Try to initialize the pool at a generic 1:1 sqrtPriceX96 and configure the buyback hook.
-        // The buyback hook constructs the PoolKey internally from the project token, terminal token, and pool params.
-        // slither-disable-next-line calls-loop
-        try BUYBACK_HOOK.initializePoolFor({
-            projectId: revnetId,
-            fee: DEFAULT_BUYBACK_POOL_FEE,
-            tickSpacing: DEFAULT_BUYBACK_TICK_SPACING,
-            twapWindow: DEFAULT_BUYBACK_TWAP_WINDOW,
-            terminalToken: terminalToken,
-            sqrtPriceX96: uint160(1 << 96)
-        }) {}
-            catch {} // Pool may already be initialized — that's OK.
-    }
-
     /// @notice Make a ruleset configuration for a revnet's stage.
     /// @param baseCurrency The base currency of the revnet.
     /// @param stageConfiguration The stage configuration to make a ruleset for.
@@ -565,7 +548,7 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         uint256[] memory customSplitOperatorPermissionIndexes = _extraOperatorPermissions[revnetId];
 
         // Make the array that merges the default and custom operator permissions.
-        allOperatorPermissions = new uint256[](8 + customSplitOperatorPermissionIndexes.length);
+        allOperatorPermissions = new uint256[](9 + customSplitOperatorPermissionIndexes.length);
         allOperatorPermissions[0] = JBPermissionIds.SET_SPLIT_GROUPS;
         allOperatorPermissions[1] = JBPermissionIds.SET_BUYBACK_POOL;
         allOperatorPermissions[2] = JBPermissionIds.SET_BUYBACK_TWAP;
@@ -574,13 +557,34 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         allOperatorPermissions[5] = JBPermissionIds.SUCKER_SAFETY;
         allOperatorPermissions[6] = JBPermissionIds.SET_BUYBACK_HOOK;
         allOperatorPermissions[7] = JBPermissionIds.SET_ROUTER_TERMINAL;
+        allOperatorPermissions[8] = JBPermissionIds.SET_TOKEN_METADATA;
 
         // Copy the custom permissions into the array.
         for (uint256 i; i < customSplitOperatorPermissionIndexes.length; i++) {
-            allOperatorPermissions[8 + i] = customSplitOperatorPermissionIndexes[i];
+            allOperatorPermissions[9 + i] = customSplitOperatorPermissionIndexes[i];
         }
     }
 
+    /// @notice Try to initialize a Uniswap V4 buyback pool for a terminal token at a generic 1:1 price.
+    /// @dev Called after the ERC-20 token is deployed so the pool can be initialized in the PoolManager.
+    /// Silently catches failures (e.g., if the pool is already initialized).
+    /// @param revnetId The ID of the revnet.
+    /// @param terminalToken The terminal token to initialize a buyback pool for.
+    function _tryInitializeBuybackPoolFor(uint256 revnetId, address terminalToken) internal {
+        // Try to initialize the pool at a generic 1:1 sqrtPriceX96 and configure the buyback hook.
+        // The buyback hook constructs the PoolKey internally from the project token, terminal token, and pool params.
+        // slither-disable-next-line calls-loop
+        try BUYBACK_HOOK.initializePoolFor({
+            projectId: revnetId,
+            fee: DEFAULT_BUYBACK_POOL_FEE,
+            tickSpacing: DEFAULT_BUYBACK_TICK_SPACING,
+            twapWindow: DEFAULT_BUYBACK_TWAP_WINDOW,
+            terminalToken: terminalToken,
+            sqrtPriceX96: uint160(1 << 96)
+        }) {}
+            catch {} // Pool may already be initialized — that's OK.
+    }
+
     //*********************************************************************//
     // --------------------- external transactions ----------------------- //
     //*********************************************************************//
@@ -648,7 +652,13 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     /// @param stageId The ID of the stage auto-mint tokens are available from.
     /// @param beneficiary The address to auto-mint tokens to.
     function autoIssueFor(uint256 revnetId, uint256 stageId, address beneficiary) external override {
-        // Get a reference to the ruleset for the stage.
+        // Get the ruleset for the stage to check if it has started.
+        // Stage IDs are `block.timestamp + i` where `i` is the stage index. These match real JB ruleset IDs
+        // because JBRulesets assigns IDs the same way: `latestId >= block.timestamp ? latestId + 1 : block.timestamp`
+        // (see JBRulesets.sol L172). When all stages are queued in a single deployFor() call, the sequential
+        // IDs `block.timestamp`, `block.timestamp + 1`, ... exactly correspond to the JB-assigned ruleset IDs.
+        // The returned `ruleset.start` contains the derived start time (from `deriveStartFrom` using the stage's
+        // `mustStartAtOrAfter`), NOT the queue timestamp — so the timing guard correctly blocks early claims.
         // slither-disable-next-line unused-return
         (JBRuleset memory ruleset,) = CONTROLLER.getRulesetOf({projectId: revnetId, rulesetId: stageId});
 
@@ -677,6 +687,17 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         });
     }
 
+    /// @notice Burn any of a revnet's tokens held by this contract.
+    /// @dev Project tokens can end up here from reserved token distribution when splits don't sum to 100%.
+    /// @param revnetId The ID of the revnet whose tokens should be burned.
+    function burnHeldTokensOf(uint256 revnetId) external override {
+        uint256 balance = CONTROLLER.TOKENS().totalBalanceOf({holder: address(this), projectId: revnetId});
+        if (balance == 0) revert REVDeployer_NothingToBurn();
+        CONTROLLER.burnTokensOf({holder: address(this), projectId: revnetId, tokenCount: balance, memo: ""});
+        // slither-disable-next-line reentrancy-events
+        emit BurnHeldTokens(revnetId, balance, _msgSender());
+    }
+
     /// @notice Launch a revnet, or initialize an existing Juicebox project as a revnet.
     /// @dev When initializing an existing project (revnetId != 0):
     /// - The project must not yet have a controller or rulesets. `JBController.launchRulesetsFor` enforces this —
@@ -691,16 +712,21 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     /// @param terminalConfigurations The terminals to set up for the revnet. Used for payments and cash outs.
     /// @param suckerDeploymentConfiguration The suckers to set up for the revnet. Suckers facilitate cross-chain
     /// token transfers between peer revnets on different networks.
+    /// @param tiered721HookConfiguration How to set up the tiered ERC-721 hook for the revnet.
+    /// @param allowedPosts Restrictions on which croptop posts are allowed on the revnet's ERC-721 tiers.
     /// @return revnetId The ID of the newly created revnet.
+    /// @return hook The address of the tiered ERC-721 hook that was deployed for the revnet.
     function deployFor(
         uint256 revnetId,
         REVConfig calldata configuration,
         JBTerminalConfig[] calldata terminalConfigurations,
-        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration
+        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration,
+        REVDeploy721TiersHookConfig calldata tiered721HookConfiguration,
+        REVCroptopAllowedPost[] calldata allowedPosts
     )
         external
         override
-        returns (uint256)
+        returns (uint256, IJB721TiersHook hook)
     {
         // Keep a reference to the revnet ID which was passed in.
         bool shouldDeployNewRevnet = revnetId == 0;
@@ -709,34 +735,69 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         // (which will be 1 greater than the current count).
         if (shouldDeployNewRevnet) revnetId = _nextProjectId();
 
-        // Normalize and encode the configurations.
-        (JBRulesetConfig[] memory rulesetConfigurations, bytes32 encodedConfigurationHash) = _makeRulesetConfigurations({
-            revnetId: revnetId, configuration: configuration, terminalConfigurations: terminalConfigurations
-        });
-
-        // Deploy the revnet.
-        _deployRevnetFor({
+        // Deploy the revnet with the specified tiered ERC-721 hook and croptop posting criteria.
+        hook = _deploy721RevnetFor({
             revnetId: revnetId,
             shouldDeployNewRevnet: shouldDeployNewRevnet,
             configuration: configuration,
             terminalConfigurations: terminalConfigurations,
             suckerDeploymentConfiguration: suckerDeploymentConfiguration,
-            rulesetConfigurations: rulesetConfigurations,
-            encodedConfigurationHash: encodedConfigurationHash
+            tiered721HookConfiguration: tiered721HookConfiguration,
+            allowedPosts: allowedPosts
         });
 
-        return revnetId;
+        return (revnetId, hook);
     }
 
-    /// @notice Burn any of a revnet's tokens held by this contract.
-    /// @dev Project tokens can end up here from reserved token distribution when splits don't sum to 100%.
-    /// @param revnetId The ID of the revnet whose tokens should be burned.
-    function burnHeldTokensOf(uint256 revnetId) external override {
-        uint256 balance = CONTROLLER.TOKENS().totalBalanceOf({holder: address(this), projectId: revnetId});
-        if (balance == 0) revert REVDeployer_NothingToBurn();
-        CONTROLLER.burnTokensOf({holder: address(this), projectId: revnetId, tokenCount: balance, memo: ""});
-        // slither-disable-next-line reentrancy-events
-        emit BurnHeldTokens(revnetId, balance, _msgSender());
+    /// @inheritdoc IREVDeployer
+    function deployFor(
+        uint256 revnetId,
+        REVConfig calldata configuration,
+        JBTerminalConfig[] calldata terminalConfigurations,
+        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration
+    )
+        external
+        override
+        returns (uint256, IJB721TiersHook hook)
+    {
+        bool shouldDeployNewRevnet = revnetId == 0;
+        if (shouldDeployNewRevnet) revnetId = _nextProjectId();
+
+        // Deploy the revnet (project, rulesets, ERC-20, suckers, etc.).
+        bytes32 encodedConfigurationHash = _deployRevnetFor({
+            revnetId: revnetId,
+            shouldDeployNewRevnet: shouldDeployNewRevnet,
+            configuration: configuration,
+            terminalConfigurations: terminalConfigurations,
+            suckerDeploymentConfiguration: suckerDeploymentConfiguration
+        });
+
+        // Deploy a default empty 721 hook for the revnet.
+        {
+            JBDeploy721TiersHookConfig memory deployConfig;
+            deployConfig.tiersConfig.currency = configuration.baseCurrency;
+            deployConfig.tiersConfig.decimals = 18;
+
+            hook = HOOK_DEPLOYER.deployHookFor({
+                projectId: revnetId,
+                deployTiersHookConfig: deployConfig,
+                salt: keccak256(abi.encode(bytes32(0), encodedConfigurationHash, _msgSender()))
+            });
+        }
+
+        // Store the tiered ERC-721 hook.
+        tiered721HookOf[revnetId] = hook;
+
+        // Grant the split operator all 721 permissions (no prevent* flags for default config).
+        _extraOperatorPermissions[revnetId].push(JBPermissionIds.ADJUST_721_TIERS);
+        _extraOperatorPermissions[revnetId].push(JBPermissionIds.SET_721_METADATA);
+        _extraOperatorPermissions[revnetId].push(JBPermissionIds.MINT_721);
+        _extraOperatorPermissions[revnetId].push(JBPermissionIds.SET_721_DISCOUNT_PERCENT);
+
+        // Give the split operator their permissions (base + 721 extras).
+        _setSplitOperatorOf({revnetId: revnetId, operator: configuration.splitOperator});
+
+        return (revnetId, hook);
     }
 
     /// @notice Deploy new suckers for an existing revnet.
@@ -775,51 +836,6 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
         });
     }
 
-    /// @notice Launch a revnet which sells tiered ERC-721s and (optionally) allows croptop posts to its ERC-721 tiers.
-    /// @dev When initializing an existing project (revnetId != 0), the project must be blank (no controller or
-    /// rulesets). The initialization is irreversible. See `deployFor` documentation for full details.
-    /// @param revnetId The ID of the Juicebox project to initialize as a revnet. Send 0 to deploy a new revnet.
-    /// @param configuration Core revnet configuration. See `REVConfig`.
-    /// @param terminalConfigurations The terminals to set up for the revnet. Used for payments and cash outs.
-    /// @param suckerDeploymentConfiguration The suckers to set up for the revnet. Suckers facilitate cross-chain
-    /// token transfers between peer revnets on different networks.
-    /// @param tiered721HookConfiguration How to set up the tiered ERC-721 hook for the revnet.
-    /// @param allowedPosts Restrictions on which croptop posts are allowed on the revnet's ERC-721 tiers.
-    /// @return revnetId The ID of the newly created revnet.
-    /// @return hook The address of the tiered ERC-721 hook that was deployed for the revnet.
-    function deployWith721sFor(
-        uint256 revnetId,
-        REVConfig calldata configuration,
-        JBTerminalConfig[] calldata terminalConfigurations,
-        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration,
-        REVDeploy721TiersHookConfig calldata tiered721HookConfiguration,
-        REVCroptopAllowedPost[] calldata allowedPosts
-    )
-        external
-        override
-        returns (uint256, IJB721TiersHook hook)
-    {
-        // Keep a reference to the revnet ID which was passed in.
-        bool shouldDeployNewRevnet = revnetId == 0;
-
-        // If the caller is deploying a new revnet, calculate its ID
-        // (which will be 1 greater than the current count).
-        if (shouldDeployNewRevnet) revnetId = _nextProjectId();
-
-        // Deploy the revnet with the specified tiered ERC-721 hook and croptop posting criteria.
-        hook = _deploy721RevnetFor({
-            revnetId: revnetId,
-            shouldDeployNewRevnet: shouldDeployNewRevnet,
-            configuration: configuration,
-            terminalConfigurations: terminalConfigurations,
-            suckerDeploymentConfiguration: suckerDeploymentConfiguration,
-            tiered721HookConfiguration: tiered721HookConfiguration,
-            allowedPosts: allowedPosts
-        });
-
-        return (revnetId, hook);
-    }
-
     /// @notice Change a revnet's split operator.
     /// @dev Only a revnet's current split operator can set a new split operator.
     /// @param revnetId The ID of the revnet to set the split operator of.
@@ -852,91 +868,86 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     function _beforeTransferTo(address to, address token, uint256 amount) internal returns (uint256) {
         // If the token is the native token, no allowance needed.
         if (token == JBConstants.NATIVE_TOKEN) return amount;
-        IERC20(token).safeIncreaseAllowance(to, amount);
+        IERC20(token).safeIncreaseAllowance({spender: to, value: amount});
         return 0;
     }
 
     /// @notice Deploy a revnet which sells tiered ERC-721s and (optionally) allows croptop posts to its ERC-721 tiers.
-    /// @param revnetId The ID of the Juicebox project to turn into a revnet. Send 0 to deploy a new revnet.
-    /// @param shouldDeployNewRevnet Whether to deploy a new revnet or convert an existing Juicebox project into a
-    /// revnet.
-    /// @param configuration Core revnet configuration. See `REVConfig`.
-    /// @param terminalConfigurations The terminals to set up for the revnet. Used for payments and cash outs.
-    /// @param suckerDeploymentConfiguration The suckers to set up for the revnet. Suckers facilitate cross-chain
-    /// token transfers between peer revnets on different networks.
-    /// @param tiered721HookConfiguration How to set up the tiered ERC-721 hook for the revnet.
-    /// @param allowedPosts Restrictions on which croptop posts are allowed on the revnet's ERC-721 tiers.
-    /// @return hook The address of the tiered ERC-721 hook that was deployed for the revnet.
     function _deploy721RevnetFor(
         uint256 revnetId,
         bool shouldDeployNewRevnet,
         REVConfig calldata configuration,
         JBTerminalConfig[] calldata terminalConfigurations,
         REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration,
-        REVDeploy721TiersHookConfig calldata tiered721HookConfiguration,
-        REVCroptopAllowedPost[] calldata allowedPosts
+        REVDeploy721TiersHookConfig memory tiered721HookConfiguration,
+        REVCroptopAllowedPost[] memory allowedPosts
     )
         internal
         returns (IJB721TiersHook hook)
     {
-        // Normalize and encode the configurations.
-        (JBRulesetConfig[] memory rulesetConfigurations, bytes32 encodedConfigurationHash) = _makeRulesetConfigurations({
-            revnetId: revnetId, configuration: configuration, terminalConfigurations: terminalConfigurations
+        // Deploy the revnet (project, rulesets, ERC-20, suckers, etc.).
+        bytes32 encodedConfigurationHash = _deployRevnetFor({
+            revnetId: revnetId,
+            shouldDeployNewRevnet: shouldDeployNewRevnet,
+            configuration: configuration,
+            terminalConfigurations: terminalConfigurations,
+            suckerDeploymentConfiguration: suckerDeploymentConfiguration
         });
 
         // Convert the REVBaseline721HookConfig to JBDeploy721TiersHookConfig, forcing issueTokensForSplits to false.
         // Revnets do their own weight adjustment for splits, so the 721 hook must not also adjust.
-        JBDeploy721TiersHookConfig memory hookConfig = JBDeploy721TiersHookConfig({
-            name: tiered721HookConfiguration.baseline721HookConfiguration.name,
-            symbol: tiered721HookConfiguration.baseline721HookConfiguration.symbol,
-            baseUri: tiered721HookConfiguration.baseline721HookConfiguration.baseUri,
-            tokenUriResolver: tiered721HookConfiguration.baseline721HookConfiguration.tokenUriResolver,
-            contractUri: tiered721HookConfiguration.baseline721HookConfiguration.contractUri,
-            tiersConfig: tiered721HookConfiguration.baseline721HookConfiguration.tiersConfig,
-            reserveBeneficiary: tiered721HookConfiguration.baseline721HookConfiguration.reserveBeneficiary,
-            flags: JB721TiersHookFlags({
-                noNewTiersWithReserves: tiered721HookConfiguration.baseline721HookConfiguration.flags
-                .noNewTiersWithReserves,
-                noNewTiersWithVotes: tiered721HookConfiguration.baseline721HookConfiguration.flags.noNewTiersWithVotes,
-                noNewTiersWithOwnerMinting: tiered721HookConfiguration.baseline721HookConfiguration.flags
-                .noNewTiersWithOwnerMinting,
-                preventOverspending: tiered721HookConfiguration.baseline721HookConfiguration.flags.preventOverspending,
-                issueTokensForSplits: false
-            })
-        });
-
-        // Deploy the tiered ERC-721 hook contract.
-        // slither-disable-next-line reentrancy-benign
         hook = HOOK_DEPLOYER.deployHookFor({
             projectId: revnetId,
-            deployTiersHookConfig: hookConfig,
+            deployTiersHookConfig: JBDeploy721TiersHookConfig({
+                name: tiered721HookConfiguration.baseline721HookConfiguration.name,
+                symbol: tiered721HookConfiguration.baseline721HookConfiguration.symbol,
+                baseUri: tiered721HookConfiguration.baseline721HookConfiguration.baseUri,
+                tokenUriResolver: tiered721HookConfiguration.baseline721HookConfiguration.tokenUriResolver,
+                contractUri: tiered721HookConfiguration.baseline721HookConfiguration.contractUri,
+                tiersConfig: tiered721HookConfiguration.baseline721HookConfiguration.tiersConfig,
+                reserveBeneficiary: tiered721HookConfiguration.baseline721HookConfiguration.reserveBeneficiary,
+                flags: JB721TiersHookFlags({
+                    noNewTiersWithReserves: tiered721HookConfiguration.baseline721HookConfiguration.flags
+                    .noNewTiersWithReserves,
+                    noNewTiersWithVotes: tiered721HookConfiguration.baseline721HookConfiguration.flags
+                        .noNewTiersWithVotes,
+                    noNewTiersWithOwnerMinting: tiered721HookConfiguration.baseline721HookConfiguration.flags
+                        .noNewTiersWithOwnerMinting,
+                    preventOverspending: tiered721HookConfiguration.baseline721HookConfiguration.flags
+                        .preventOverspending,
+                    issueTokensForSplits: false
+                })
+            }),
             salt: keccak256(abi.encode(tiered721HookConfiguration.salt, encodedConfigurationHash, _msgSender()))
         });
 
         // Store the tiered ERC-721 hook.
         tiered721HookOf[revnetId] = hook;
 
-        // If specified, give the split operator permission to add and remove tiers.
-        if (tiered721HookConfiguration.splitOperatorCanAdjustTiers) {
+        // Give the split operator permission to add and remove tiers unless prevented.
+        if (!tiered721HookConfiguration.preventSplitOperatorAdjustingTiers) {
             _extraOperatorPermissions[revnetId].push(JBPermissionIds.ADJUST_721_TIERS);
         }
 
-        // If specified, give the split operator permission to set ERC-721 tier metadata.
-        if (tiered721HookConfiguration.splitOperatorCanUpdateMetadata) {
+        // Give the split operator permission to set ERC-721 tier metadata unless prevented.
+        if (!tiered721HookConfiguration.preventSplitOperatorUpdatingMetadata) {
             _extraOperatorPermissions[revnetId].push(JBPermissionIds.SET_721_METADATA);
         }
 
-        // If specified, give the split operator permission to mint ERC-721s (without a payment)
-        // from tiers with `allowOwnerMint` set to true.
-        if (tiered721HookConfiguration.splitOperatorCanMint) {
+        // Give the split operator permission to mint ERC-721s (without a payment)
+        // from tiers with `allowOwnerMint` set to true, unless prevented.
+        if (!tiered721HookConfiguration.preventSplitOperatorMinting) {
             _extraOperatorPermissions[revnetId].push(JBPermissionIds.MINT_721);
         }
 
-        // If specified, give the split operator permission to increase the discount of a tier.
-        if (tiered721HookConfiguration.splitOperatorCanIncreaseDiscountPercent) {
+        // Give the split operator permission to increase the discount of a tier unless prevented.
+        if (!tiered721HookConfiguration.preventSplitOperatorIncreasingDiscountPercent) {
             _extraOperatorPermissions[revnetId].push(JBPermissionIds.SET_721_DISCOUNT_PERCENT);
         }
 
+        // Give the split operator their permissions (base + 721 extras).
+        _setSplitOperatorOf({revnetId: revnetId, operator: configuration.splitOperator});
+
         // If there are posts to allow, configure them.
         if (allowedPosts.length != 0) {
             // Keep a reference to the formatted allowed posts.
@@ -945,7 +956,7 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
             // Iterate through each post to add it to the formatted list.
             for (uint256 i; i < allowedPosts.length; i++) {
                 // Set the post being iterated on.
-                REVCroptopAllowedPost calldata post = allowedPosts[i];
+                REVCroptopAllowedPost memory post = allowedPosts[i];
 
                 // Set the formatted post.
                 formattedAllowedPosts[i] = CTAllowedPost({
@@ -967,16 +978,6 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
                 operator: address(PUBLISHER), revnetId: revnetId, permissionId: JBPermissionIds.ADJUST_721_TIERS
             });
         }
-
-        _deployRevnetFor({
-            revnetId: revnetId,
-            shouldDeployNewRevnet: shouldDeployNewRevnet,
-            configuration: configuration,
-            terminalConfigurations: terminalConfigurations,
-            suckerDeploymentConfiguration: suckerDeploymentConfiguration,
-            rulesetConfigurations: rulesetConfigurations,
-            encodedConfigurationHash: encodedConfigurationHash
-        });
     }
 
     /// @notice Deploy a revnet, or initialize an existing Juicebox project as a revnet.
@@ -993,21 +994,22 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     /// @param terminalConfigurations The terminals to set up for the revnet. Used for payments and cash outs.
     /// @param suckerDeploymentConfiguration The suckers to set up for the revnet. Suckers facilitate cross-chain
     /// token transfers between peer revnets on different networks.
-    /// @param rulesetConfigurations The rulesets to set up for the revnet.
-    /// @param encodedConfigurationHash A hash that represents the revnet's configuration.
-    /// See `_makeRulesetConfigurations(…)` for encoding details. Clients can read the encoded configuration
-    /// from the `DeployRevnet` event emitted by this contract.
+    /// @return encodedConfigurationHash A hash that represents the revnet's configuration.
     function _deployRevnetFor(
         uint256 revnetId,
         bool shouldDeployNewRevnet,
         REVConfig calldata configuration,
         JBTerminalConfig[] calldata terminalConfigurations,
-        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration,
-        JBRulesetConfig[] memory rulesetConfigurations,
-        bytes32 encodedConfigurationHash
+        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration
     )
         internal
+        returns (bytes32 encodedConfigurationHash)
     {
+        // Normalize and encode the configurations.
+        JBRulesetConfig[] memory rulesetConfigurations;
+        (rulesetConfigurations, encodedConfigurationHash) = _makeRulesetConfigurations({
+            revnetId: revnetId, configuration: configuration, terminalConfigurations: terminalConfigurations
+        });
         if (shouldDeployNewRevnet) {
             // If we're deploying a new revnet, launch a Juicebox project for it.
             // Sanity check that we deployed the `revnetId` that we expected to deploy.
@@ -1064,13 +1066,12 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
             JBTerminalConfig calldata terminalConfiguration = terminalConfigurations[i];
             for (uint256 j; j < terminalConfiguration.accountingContextsToAccept.length; j++) {
                 // slither-disable-next-line calls-loop
-                _tryInitializeBuybackPoolFor(revnetId, terminalConfiguration.accountingContextsToAccept[j].token);
+                _tryInitializeBuybackPoolFor({
+                    revnetId: revnetId, terminalToken: terminalConfiguration.accountingContextsToAccept[j].token
+                });
             }
         }
 
-        // Give the split operator their permissions.
-        _setSplitOperatorOf({revnetId: revnetId, operator: configuration.splitOperator});
-
         // Deploy the suckers (if applicable).
         if (suckerDeploymentConfiguration.salt != bytes32(0)) {
             _deploySuckersFor({
@@ -1130,6 +1131,9 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     /// of collateral) or lower issuance weight (reducing the surplus-per-token ratio). Borrowers should monitor
     /// upcoming stage transitions and adjust their positions accordingly, as loans that fall below their required
     /// collateralization may become eligible for liquidation.
+    /// @dev `cashOutTaxRate` changes at stage boundaries may allow users to cash out just before a rate increase.
+    /// This is accepted behavior — the arbitrage window is bounded by the ruleset design, and all stages are
+    /// configured immutably at deployment time.
     /// @param revnetId The ID of the revnet to make rulesets for.
     /// @param configuration The configuration containing the revnet's stages.
     /// @param terminalConfigurations The terminals to set up for the revnet. Used for payments and cash outs.
@@ -1237,8 +1241,11 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
                 });
 
                 // Store the amount of tokens that can be auto-minted on this chain during this stage.
-                // The first stage ID is stored at this block's timestamp,
-                // and further stage IDs have incrementally increasing IDs
+                // The stage ID is `block.timestamp + i`. This matches the ruleset ID that JBRulesets assigns
+                // because JBRulesets uses `latestId >= block.timestamp ? latestId + 1 : block.timestamp`
+                // (JBRulesets.sol L172), producing the same sequential IDs when all stages are queued in one tx.
+                // `autoIssueFor` later calls `getRulesetOf(revnetId, stageId)` — the returned `ruleset.start`
+                // is the derived start time (not the queue time), so the timing guard works correctly.
                 // slither-disable-next-line reentrancy-benign
                 amountToAutoIssue[revnetId][block.timestamp + i][autoIssuance.beneficiary] += autoIssuance.count;
             }
@@ -1296,7 +1303,8 @@ contract REVDeployer is ERC2771Context, IREVDeployer, IJBRulesetDataHook, IJBCas
     {
         // Set up the permission data.
         JBPermissionsData memory permissionData =
-            JBPermissionsData({operator: operator, projectId: uint64(revnetId), permissionIds: permissionIds});
+        // forge-lint: disable-next-line(unsafe-typecast)
+        JBPermissionsData({operator: operator, projectId: uint64(revnetId), permissionIds: permissionIds});
 
         // Set the permissions.
         PERMISSIONS.setPermissionsFor({account: account, permissionsData: permissionData});