@ballkidz/defifa 0.0.6 → 0.0.8

package/src/DefifaDeployer.sol

@@ -1,50 +1,43 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.26;
 
-import {mulDiv} from "@prb/math/src/Common.sol";
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
+import {
+    JB721TiersRulesetMetadata,
+    JB721TiersRulesetMetadataResolver
+} from "@bananapus/721-hook-v6/src/libraries/JB721TiersRulesetMetadataResolver.sol";
+import {JB721TierConfig} from "@bananapus/721-hook-v6/src/structs/JB721TierConfig.sol";
+import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
+import {IJBController, JBRulesetConfig, JBTerminalConfig} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBMultiTerminal} from "@bananapus/core-v6/src/interfaces/IJBMultiTerminal.sol";
+import {IJBRulesetApprovalHook, JBRuleset} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
+import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
+import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {JBCurrencyAmount} from "@bananapus/core-v6/src/structs/JBCurrencyAmount.sol";
+import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
-import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {DefifaHook} from "./DefifaHook.sol";
 import {DefifaGamePhase} from "./enums/DefifaGamePhase.sol";
 import {IDefifaDeployer} from "./interfaces/IDefifaDeployer.sol";
-import {IDefifaHook} from "./interfaces/IDefifaHook.sol";
 import {IDefifaGamePhaseReporter} from "./interfaces/IDefifaGamePhaseReporter.sol";
 import {IDefifaGamePotReporter} from "./interfaces/IDefifaGamePotReporter.sol";
 import {IDefifaGovernor} from "./interfaces/IDefifaGovernor.sol";
+import {IDefifaHook} from "./interfaces/IDefifaHook.sol";
 import {DefifaLaunchProjectData} from "./structs/DefifaLaunchProjectData.sol";
-import {DefifaTierParams} from "./structs/DefifaTierParams.sol";
 import {DefifaOpsData} from "./structs/DefifaOpsData.sol";
-import {DefifaHook} from "./DefifaHook.sol";
-import {DefifaTokenUriResolver} from "./DefifaTokenUriResolver.sol";
-
-import {IJBToken} from "@bananapus/core-v6/src/interfaces/IJBToken.sol";
-import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
-import {IJBController, JBRulesetConfig, JBTerminalConfig} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
-import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
-import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
-import {IJBMultiTerminal} from "@bananapus/core-v6/src/interfaces/IJBMultiTerminal.sol";
-import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
-import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
-import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
-import {JBCurrencyAmount} from "@bananapus/core-v6/src/structs/JBCurrencyAmount.sol";
-import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
-import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
-import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
-import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
-import {JB721TierConfig} from "@bananapus/721-hook-v6/src/structs/JB721TierConfig.sol";
-import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
-import {JBSplitHookContext} from "@bananapus/core-v6/src/structs/JBSplitHookContext.sol";
-import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
-import {
-    JB721TiersRulesetMetadata,
-    JB721TiersRulesetMetadataResolver
-} from "@bananapus/721-hook-v6/src/libraries/JB721TiersRulesetMetadataResolver.sol";
-import {IJBRulesets, IJBRulesetApprovalHook, JBRuleset} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
+import {DefifaTierParams} from "./structs/DefifaTierParams.sol";
 
-/// @title DefifaDeployer
 /// @notice Deploys and manages Defifa games.
 contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGamePotReporter, IERC721Receiver {
     using Strings for uint256;
@@ -55,7 +48,6 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
     //*********************************************************************//
 
     error DefifaDeployer_CantFulfillYet();
-    error DefifaDeployer_NothingToFulfill();
     error DefifaDeployer_GameOver();
     error DefifaDeployer_InvalidFeePercent();
     error DefifaDeployer_InvalidGameConfiguration();
@@ -84,29 +76,29 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
     /// @notice The group relative to which splits are stored.
     /// @dev This could be any fixed number.
-    uint256 public immutable override splitGroup;
+    uint256 public immutable override SPLIT_GROUP;
 
     /// @notice The project ID that'll receive game fees, and relative to which splits are stored.
     /// @dev The owner of this project ID must give this contract operator permissions over the SET_SPLITS operation.
-    uint256 public immutable override defifaProjectId;
+    uint256 public immutable override DEFIFA_PROJECT_ID;
 
     /// @notice The project ID that'll receive protocol fees as commitments are fulfilled.
-    uint256 public immutable override baseProtocolProjectId;
+    uint256 public immutable override BASE_PROTOCOL_PROJECT_ID;
 
     /// @notice The original code for the Defifa hook to base subsequent instances on.
-    address public immutable override hookCodeOrigin;
+    address public immutable override HOOK_CODE_ORIGIN;
 
     /// @notice The default Defifa token URI resolver.
-    IJB721TokenUriResolver public immutable override tokenUriResolver;
+    IJB721TokenUriResolver public immutable override TOKEN_URI_RESOLVER;
 
     /// @notice The Defifa governor.
-    IDefifaGovernor public immutable override governor;
+    IDefifaGovernor public immutable override GOVERNOR;
 
     /// @notice The controller with which new projects should be deployed.
-    IJBController public immutable override controller;
+    IJBController public immutable override CONTROLLER;
 
     /// @notice The hooks registry.
-    IJBAddressRegistry public immutable registry;
+    IJBAddressRegistry public immutable REGISTRY;
 
     /// @notice The divisor that describes the protocol fee that should be taken.
     /// @dev This is equal to 100 divided by the fee percent (e.g. 40 = 2.5% fee).
@@ -154,7 +146,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         address _token = _opsOf[gameId].token;
 
         // Get a reference to the terminal.
-        IJBTerminal _terminal = controller.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _token});
+        IJBTerminal _terminal = CONTROLLER.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _token});
 
         // Get the accounting context for the project.
         JBAccountingContext memory _context = _terminal.accountingContextForTokenOf({projectId: gameId, token: _token});
@@ -174,10 +166,10 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
     /// @return Whether or not the next phase still needs queuing.
     function nextPhaseNeedsQueueing(uint256 gameId) external view override returns (bool) {
         // Get the game's current funding cycle along with its metadata.
-        JBRuleset memory _currentRuleset = controller.RULESETS().currentOf(gameId);
+        JBRuleset memory _currentRuleset = CONTROLLER.RULESETS().currentOf(gameId);
         // Get the game's queued funding cycle along with its metadata.
         // slither-disable-next-line unused-return
-        (JBRuleset memory _queuedRuleset,) = controller.RULESETS().latestQueuedOf(gameId);
+        (JBRuleset memory _queuedRuleset,) = CONTROLLER.RULESETS().latestQueuedOf(gameId);
 
         // If the configurations are the same and the game hasn't ended, queueing is still needed.
         return _currentRuleset.duration != 0 && _currentRuleset.id == _queuedRuleset.id;
@@ -226,7 +218,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
     /// @return The game phase.
     function currentGamePhaseOf(uint256 gameId) public view override returns (DefifaGamePhase) {
         // Get the game's current funding cycle along with its metadata.
-        (JBRuleset memory _currentRuleset, JBRulesetMetadata memory _metadata) = controller.currentRulesetOf(gameId);
+        (JBRuleset memory _currentRuleset, JBRulesetMetadata memory _metadata) = CONTROLLER.currentRulesetOf(gameId);
 
         if (_currentRuleset.cycleNumber == 0) return DefifaGamePhase.COUNTDOWN;
         if (_currentRuleset.cycleNumber == 1) return DefifaGamePhase.MINT;
@@ -247,7 +239,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // Check minimum participation threshold: if the treasury balance is below the threshold, the game is
         // NO_CONTEST.
         if (_ops.minParticipation > 0) {
-            IJBTerminal _terminal = controller.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _ops.token});
+            IJBTerminal _terminal = CONTROLLER.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _ops.token});
             uint256 _balance = IJBMultiTerminal(address(_terminal)).STORE()
                 .balanceOf({terminal: address(_terminal), projectId: gameId, token: _ops.token});
             if (_balance < _ops.minParticipation) return DefifaGamePhase.NO_CONTEST;
@@ -282,15 +274,15 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         uint256 _defifaProjectId,
         uint256 _baseProtocolProjectId
     ) {
-        hookCodeOrigin = _hookCodeOrigin;
-        tokenUriResolver = _tokenUriResolver;
-        governor = _governor;
-        controller = _controller;
-        registry = _registry;
-        defifaProjectId = _defifaProjectId;
-        baseProtocolProjectId = _baseProtocolProjectId;
+        HOOK_CODE_ORIGIN = _hookCodeOrigin;
+        TOKEN_URI_RESOLVER = _tokenUriResolver;
+        GOVERNOR = _governor;
+        CONTROLLER = _controller;
+        REGISTRY = _registry;
+        DEFIFA_PROJECT_ID = _defifaProjectId;
+        BASE_PROTOCOL_PROJECT_ID = _baseProtocolProjectId;
         /// @dev Uses the deployer address as group ID. Game scoring rulesets use uint160(token) as group ID.
-        splitGroup = uint256(uint160(address(this)));
+        SPLIT_GROUP = uint256(uint160(address(this)));
     }
 
     //*********************************************************************//
@@ -305,7 +297,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
         // Get the game's current funding cycle along with its metadata.
         // slither-disable-next-line unused-return
-        (, JBRulesetMetadata memory _metadata) = controller.currentRulesetOf(gameId);
+        (, JBRulesetMetadata memory _metadata) = CONTROLLER.currentRulesetOf(gameId);
 
         // Make sure the game's commitments can be fulfilled.
         if (!IDefifaHook(_metadata.dataHook).cashOutWeightIsSet()) {
@@ -315,74 +307,49 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // Get the game token and the terminal.
         address _token = _opsOf[gameId].token;
         IJBMultiTerminal _terminal =
-            IJBMultiTerminal(address(controller.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _token})));
+            IJBMultiTerminal(address(CONTROLLER.DIRECTORY().primaryTerminalOf({projectId: gameId, token: _token})));
 
         // Get the current pot and store it. This also prevents re-entrance since the check above will return early.
         uint256 _pot = _terminal.STORE().balanceOf({terminal: address(_terminal), projectId: gameId, token: _token});
+
+        // If the pot is empty, set the sentinel and queue the final ruleset without attempting payouts.
         // slither-disable-next-line incorrect-equality
-        if (_pot == 0) revert DefifaDeployer_NothingToFulfill();
+        if (_pot == 0) {
+            fulfilledCommitmentsOf[gameId] = 1;
+            _queueFinalRuleset({gameId: gameId, metadata: _metadata});
+            emit FulfilledCommitments({gameId: gameId, pot: 0, caller: msg.sender});
+            return;
+        }
 
         // Compute the fee amount based on the total absolute split percent stored at game creation.
-        uint256 _feeAmount = mulDiv(_pot, _commitmentPercentOf[gameId], JBConstants.SPLITS_TOTAL_PERCENT);
+        uint256 _feeAmount =
+            mulDiv({x: _pot, y: _commitmentPercentOf[gameId], denominator: JBConstants.SPLITS_TOTAL_PERCENT});
 
         // Store the actual fee amount for accurate currentGamePotOf reporting.
         // Use max(feeAmount, 1) to preserve the reentrancy guard when pot is 0.
         fulfilledCommitmentsOf[gameId] = _feeAmount > 0 ? _feeAmount : 1;
 
         // Send only the fee portion as payouts. The remaining balance stays as surplus for cash-outs.
+        // Wrapped in try-catch so the final ruleset is always queued even if payout fails.
         // slither-disable-next-line unused-return
-        _terminal.sendPayoutsOf({
+        try _terminal.sendPayoutsOf({
             projectId: gameId,
             token: _token,
             amount: _feeAmount,
+            // Casting address to uint32 via uint160 is the standard Juicebox token-to-currency conversion.
+            // forge-lint: disable-next-line(unsafe-typecast)
             currency: _token == JBConstants.NATIVE_TOKEN ? _metadata.baseCurrency : uint32(uint160(_token)),
-            minTokensPaidOut: _feeAmount
-        });
-
-        // Queue the final ruleset.
-        JBRulesetConfig[] memory rulesetConfigs = new JBRulesetConfig[](1);
-        rulesetConfigs[0] = JBRulesetConfig({
-            mustStartAtOrAfter: 0,
-            duration: 0,
-            weight: 0,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: JBRulesetMetadata({
-                reservedPercent: 0,
-                cashOutTaxRate: 0,
-                baseCurrency: _metadata.baseCurrency,
-                pausePay: true,
-                pauseCreditTransfers: false,
-                allowOwnerMinting: false,
-                allowSetCustomToken: false,
-                allowTerminalMigration: false,
-                allowSetTerminals: false,
-                allowSetController: false,
-                allowAddAccountingContext: false,
-                allowAddPriceFeed: false,
-                // Set this to true so only the deployer can fulfill the commitments.
-                ownerMustSendPayouts: true,
-                holdFees: false,
-                useTotalSurplusForCashOuts: false,
-                useDataHookForPay: true,
-                useDataHookForCashOut: true,
-                dataHook: _metadata.dataHook,
-                metadata: uint16(
-                    JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(
-                        JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: false})
-                    )
-                )
-            }),
-            // No more payouts.
-            splitGroups: new JBSplitGroup[](0),
-            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
-        });
+            minTokensPaidOut: 0
+        }) {}
+        catch (bytes memory reason) {
+            // Payout failed — fee stays in pot. Reset to sentinel (1) so currentGamePotOf
+            // doesn't double-count the fee, while preserving the reentrancy guard.
+            fulfilledCommitmentsOf[gameId] = 1;
+            emit CommitmentPayoutFailed({gameId: gameId, amount: _feeAmount, reason: reason});
+        }
 
-        // Update the ruleset to the final one.
-        // slither-disable-next-line unused-return
-        controller.queueRulesetsOf({
-            projectId: gameId, rulesetConfigurations: rulesetConfigs, memo: "Defifa game has finished."
-        });
+        // Queue the final ruleset and emit.
+        _queueFinalRuleset({gameId: gameId, metadata: _metadata});
 
         emit FulfilledCommitments({gameId: gameId, pot: _pot, caller: msg.sender});
     }
@@ -419,7 +386,10 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         ) revert DefifaDeployer_InvalidGameConfiguration();
 
         // Get the game ID, optimistically knowing it will be one greater than the current count.
-        gameId = controller.PROJECTS().count() + 1;
+        // Note: this prediction can race with other concurrent project deployments. If another project is
+        // created between reading count() and launchProjectFor(), the actual ID will differ. This is
+        // caught by the equality check after launch (gameId != _actualGameId reverts).
+        gameId = CONTROLLER.PROJECTS().count() + 1;
 
         {
             // Store the timestamps that'll define the game phases.
@@ -452,8 +422,10 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
                 // Add a split for the fee.
                 _splits[_numberOfSplits] = JBSplit({
                     preferAddToBalance: false,
+                    // forge-lint: disable-next-line(unsafe-typecast)
                     percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT / DEFIFA_FEE_DIVISOR),
-                    projectId: uint64(defifaProjectId),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    projectId: uint64(DEFIFA_PROJECT_ID),
                     beneficiary: payable(address(this)),
                     lockedUntil: 0,
                     hook: IJBSplitHook(address(0))
@@ -461,11 +433,11 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
                 // Store the splits.
                 JBSplitGroup[] memory _groupedSplits = new JBSplitGroup[](1);
-                _groupedSplits[0] = JBSplitGroup({groupId: splitGroup, splits: _splits});
+                _groupedSplits[0] = JBSplitGroup({groupId: SPLIT_GROUP, splits: _splits});
 
                 // This contract must have SET_SPLIT_GROUPS permission from the defifa project owner.
-                controller.setSplitGroupsOf({
-                    projectId: defifaProjectId, rulesetId: gameId, splitGroups: _groupedSplits
+                CONTROLLER.setSplitGroupsOf({
+                    projectId: DEFIFA_PROJECT_ID, rulesetId: gameId, splitGroups: _groupedSplits
                 });
             }
         }
@@ -523,20 +495,22 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // cloneDeterministic with msg.sender in the salt prevents this since a different
         // caller produces a different address.
         DefifaHook _hook = DefifaHook(
-            Clones.cloneDeterministic(hookCodeOrigin, keccak256(abi.encodePacked(msg.sender, _currentNonce)))
+            Clones.cloneDeterministic({
+                implementation: HOOK_CODE_ORIGIN, salt: keccak256(abi.encodePacked(msg.sender, _currentNonce))
+            })
         );
 
         // Use the default uri resolver if provided, else use the hardcoded generic default.
         IJB721TokenUriResolver _uriResolver = launchProjectData.defaultTokenUriResolver
             != IJB721TokenUriResolver(address(0))
             ? launchProjectData.defaultTokenUriResolver
-            : tokenUriResolver;
+            : TOKEN_URI_RESOLVER;
 
         _hook.initialize({
             _gameId: gameId,
             _name: launchProjectData.name,
             _symbol: string.concat("DEFIFA #", gameId.toString()),
-            _rulesets: controller.RULESETS(),
+            _rulesets: CONTROLLER.RULESETS(),
             _baseUri: launchProjectData.baseUri,
             _tokenUriResolver: _uriResolver,
             _contractUri: launchProjectData.contractUri,
@@ -557,19 +531,19 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         if (gameId != _actualGameId) revert DefifaDeployer_InvalidGameConfiguration();
 
         // Clone and initialize the new governor.
-        governor.initializeGame({
+        GOVERNOR.initializeGame({
             gameId: gameId,
             attestationStartTime: uint256(launchProjectData.attestationStartTime),
             attestationGracePeriod: uint256(launchProjectData.attestationGracePeriod)
         });
 
         // Transfer ownership to the specified owner.
-        _hook.transferOwnership(address(governor));
+        _hook.transferOwnership(address(GOVERNOR));
 
         // Add the hook to the registry, contract nonce starts at 1
-        registry.registerAddress({deployer: address(this), nonce: _currentNonce});
+        REGISTRY.registerAddress({deployer: address(this), nonce: _currentNonce});
 
-        emit LaunchGame(gameId, _hook, governor, _uriResolver, msg.sender);
+        emit LaunchGame(gameId, _hook, GOVERNOR, _uriResolver, msg.sender);
     }
 
     /// @notice Allows this contract to receive 721s.
@@ -592,11 +566,15 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         if (noContestTriggeredFor[gameId]) revert DefifaDeployer_NoContestAlreadyTriggered();
 
         // Mark as triggered.
+        // Note: the queued ruleset does not take effect until the current ruleset's cycle ends (or immediately
+        // if duration is 0). During this gap, the game reports NO_CONTEST but the on-chain ruleset still has
+        // payout limits, so cash-out reclaim values may differ from the full-refund expectation. Callers
+        // should verify the active ruleset before cashing out.
         noContestTriggeredFor[gameId] = true;
 
         // Get the game's current ruleset metadata for the data hook address.
         // slither-disable-next-line unused-return
-        (, JBRulesetMetadata memory _metadata) = controller.currentRulesetOf(gameId);
+        (, JBRulesetMetadata memory _metadata) = CONTROLLER.currentRulesetOf(gameId);
 
         // Queue a new ruleset without payout limits so surplus = balance, enabling refunds.
         JBRulesetConfig[] memory rulesetConfigs = new JBRulesetConfig[](1);
@@ -637,7 +615,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
         // Queue the no-contest refund ruleset.
         // slither-disable-next-line unused-return
-        controller.queueRulesetsOf({
+        CONTROLLER.queueRulesetsOf({
             projectId: gameId, rulesetConfigurations: rulesetConfigs, memo: "Defifa game: no contest."
         });
 
@@ -648,6 +626,90 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
     // ------------------------ internal functions ----------------------- //
     //*********************************************************************//
 
+    function _buildSplits(
+        uint256 _gameId,
+        address _dataHook,
+        address _token,
+        JBSplit[] memory _initialSplits
+    )
+        internal
+        returns (JBSplitGroup[] memory)
+    {
+        uint256 _numberOfUserSplits = _initialSplits.length;
+
+        // Compute absolute percents for protocol fees.
+        uint256 _nanaAbsolutePercent = JBConstants.SPLITS_TOTAL_PERCENT / BASE_PROTOCOL_FEE_DIVISOR;
+        uint256 _defifaAbsolutePercent = JBConstants.SPLITS_TOTAL_PERCENT / DEFIFA_FEE_DIVISOR;
+
+        // Sum all absolute percents.
+        uint256 _totalAbsolutePercent = _nanaAbsolutePercent + _defifaAbsolutePercent;
+        for (uint256 _i; _i < _numberOfUserSplits; _i++) {
+            _totalAbsolutePercent += _initialSplits[_i].percent;
+        }
+
+        // Validate that total fee splits don't exceed 100%.
+        if (_totalAbsolutePercent > JBConstants.SPLITS_TOTAL_PERCENT) revert DefifaDeployer_SplitsDontAddUp();
+
+        // Store the total absolute percent for use in fulfillCommitmentsOf.
+        _commitmentPercentOf[_gameId] = _totalAbsolutePercent;
+
+        // Build the splits array: user splits + Defifa + NANA (NANA last to absorb rounding).
+        uint256 _splitCount = _numberOfUserSplits + 2;
+        JBSplit[] memory _splits = new JBSplit[](_splitCount);
+
+        // Normalize user splits and copy them over.
+        uint256 _normalizedTotal;
+        for (uint256 _i; _i < _numberOfUserSplits; _i++) {
+            _splits[_i] = _initialSplits[_i];
+            _splits[_i].percent = uint32(
+                mulDiv({
+                    x: _initialSplits[_i].percent,
+                    y: JBConstants.SPLITS_TOTAL_PERCENT,
+                    denominator: _totalAbsolutePercent
+                })
+            );
+            _normalizedTotal += _splits[_i].percent;
+        }
+
+        // Add Defifa fee split (normalized).
+        uint256 _defifaNormalized = mulDiv({
+            x: _defifaAbsolutePercent, y: JBConstants.SPLITS_TOTAL_PERCENT, denominator: _totalAbsolutePercent
+        });
+        _splits[_numberOfUserSplits] = JBSplit({
+            preferAddToBalance: false,
+            // forge-lint: disable-next-line(unsafe-typecast)
+            percent: uint32(_defifaNormalized),
+            // forge-lint: disable-next-line(unsafe-typecast)
+            projectId: uint64(DEFIFA_PROJECT_ID),
+            beneficiary: payable(address(_dataHook)),
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+        _normalizedTotal += _defifaNormalized;
+
+        // Add NANA protocol fee split last — absorbs rounding remainder from normalization.
+        // Because mulDiv rounds down, the sum of normalized percents can be slightly less than SPLITS_TOTAL_PERCENT.
+        // The NANA split receives the difference, so its effective percent may be a few basis points above its
+        // proportional share. This is economically negligible (< 1 bps at typical split counts).
+        // Beneficiary is the data hook so the hook receives NANA tokens for distribution during cash-outs.
+        _splits[_splitCount - 1] = JBSplit({
+            preferAddToBalance: false,
+            // forge-lint: disable-next-line(unsafe-typecast)
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT - _normalizedTotal),
+            // forge-lint: disable-next-line(unsafe-typecast)
+            projectId: uint64(BASE_PROTOCOL_PROJECT_ID),
+            beneficiary: payable(address(_dataHook)),
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // Build the grouped split for the payment of the game token.
+        JBSplitGroup[] memory _groupedSplits = new JBSplitGroup[](1);
+        _groupedSplits[0] = JBSplitGroup({groupId: uint256(uint160(_token)), splits: _splits});
+
+        return _groupedSplits;
+    }
+
     function _launchGame(
         DefifaLaunchProjectData memory launchProjectData,
         uint256 _gameId,
@@ -813,7 +875,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         });
 
         // launch the project.
-        return controller.launchProjectFor({
+        return CONTROLLER.launchProjectFor({
             owner: address(this),
             projectUri: launchProjectData.projectUri,
             rulesetConfigurations: rulesetConfigs,
@@ -822,74 +884,50 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         });
     }
 
-    function _buildSplits(
-        uint256 _gameId,
-        address _dataHook,
-        address _token,
-        JBSplit[] memory _initialSplits
-    )
-        internal
-        returns (JBSplitGroup[] memory)
-    {
-        uint256 _numberOfUserSplits = _initialSplits.length;
-
-        // Compute absolute percents for protocol fees.
-        uint256 _nanaAbsolutePercent = JBConstants.SPLITS_TOTAL_PERCENT / BASE_PROTOCOL_FEE_DIVISOR;
-        uint256 _defifaAbsolutePercent = JBConstants.SPLITS_TOTAL_PERCENT / DEFIFA_FEE_DIVISOR;
-
-        // Sum all absolute percents.
-        uint256 _totalAbsolutePercent = _nanaAbsolutePercent + _defifaAbsolutePercent;
-        for (uint256 _i; _i < _numberOfUserSplits; _i++) {
-            _totalAbsolutePercent += _initialSplits[_i].percent;
-        }
-
-        // Validate that total fee splits don't exceed 100%.
-        if (_totalAbsolutePercent > JBConstants.SPLITS_TOTAL_PERCENT) revert DefifaDeployer_SplitsDontAddUp();
-
-        // Store the total absolute percent for use in fulfillCommitmentsOf.
-        _commitmentPercentOf[_gameId] = _totalAbsolutePercent;
-
-        // Build the splits array: user splits + Defifa + NANA (NANA last to absorb rounding).
-        uint256 _splitCount = _numberOfUserSplits + 2;
-        JBSplit[] memory _splits = new JBSplit[](_splitCount);
-
-        // Normalize user splits and copy them over.
-        uint256 _normalizedTotal;
-        for (uint256 _i; _i < _numberOfUserSplits; _i++) {
-            _splits[_i] = _initialSplits[_i];
-            _splits[_i].percent =
-                uint32(mulDiv(_initialSplits[_i].percent, JBConstants.SPLITS_TOTAL_PERCENT, _totalAbsolutePercent));
-            _normalizedTotal += _splits[_i].percent;
-        }
-
-        // Add Defifa fee split (normalized).
-        uint256 _defifaNormalized =
-            mulDiv(_defifaAbsolutePercent, JBConstants.SPLITS_TOTAL_PERCENT, _totalAbsolutePercent);
-        _splits[_numberOfUserSplits] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(_defifaNormalized),
-            projectId: uint64(defifaProjectId),
-            beneficiary: payable(address(_dataHook)),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
+    /// @notice Queues the final ruleset for a game: no payouts, no fund access limits, surplus = entire balance.
+    /// @param gameId The ID of the game.
+    /// @param metadata The current ruleset metadata (used to carry forward baseCurrency and dataHook).
+    function _queueFinalRuleset(uint256 gameId, JBRulesetMetadata memory metadata) internal {
+        JBRulesetConfig[] memory rulesetConfigs = new JBRulesetConfig[](1);
+        rulesetConfigs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: JBRulesetMetadata({
+                reservedPercent: 0,
+                cashOutTaxRate: 0,
+                baseCurrency: metadata.baseCurrency,
+                pausePay: true,
+                pauseCreditTransfers: false,
+                allowOwnerMinting: false,
+                allowSetCustomToken: false,
+                allowTerminalMigration: false,
+                allowSetTerminals: false,
+                allowSetController: false,
+                allowAddAccountingContext: false,
+                allowAddPriceFeed: false,
+                ownerMustSendPayouts: false,
+                holdFees: false,
+                useTotalSurplusForCashOuts: false,
+                useDataHookForPay: true,
+                useDataHookForCashOut: true,
+                dataHook: metadata.dataHook,
+                metadata: uint16(
+                    JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(
+                        JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: false})
+                    )
+                )
+            }),
+            // No more payouts.
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
         });
-        _normalizedTotal += _defifaNormalized;
 
-        // Add NANA protocol fee split last — absorbs rounding remainder.
-        // Beneficiary is the data hook so the hook receives NANA tokens for distribution during cash-outs.
-        _splits[_splitCount - 1] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT - _normalizedTotal),
-            projectId: uint64(baseProtocolProjectId),
-            beneficiary: payable(address(_dataHook)),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
+        // slither-disable-next-line unused-return
+        CONTROLLER.queueRulesetsOf({
+            projectId: gameId, rulesetConfigurations: rulesetConfigs, memo: "Defifa game has finished."
         });
-
-        // Build the grouped split for the payment of the game token.
-        JBSplitGroup[] memory _groupedSplits = new JBSplitGroup[](1);
-        _groupedSplits[0] = JBSplitGroup({groupId: uint256(uint160(_token)), splits: _splits});
-
-        return _groupedSplits;
     }
 }