@ballkidz/defifa 0.0.23 → 0.0.24

package/CHANGELOG.md

@@ -20,6 +20,10 @@ This file instead describes the current v6 repo at a high level and the broad mi
 - The v6 surface is split across dedicated deployer, hook, governor, project-owner, and token-uri contracts, with dedicated regression and audit test coverage around governance, fee accounting, attestations, and lifecycle edge cases.
 - Solidity and tooling were upgraded to the v6 baseline around `0.8.28`.
 
+## Local audit remediations
+
+- Reserve-minted NFTs are now excluded from refund calculations during MINT, REFUND, and NO_CONTEST phases. A public `isReserveMint` mapping tracks which tokens were created via tier reserve frequency rather than paid for. `beforeCashOutRecordedWith` subtracts their tier price from `cumulativeMintPrice`, preventing reserve beneficiaries from withdrawing funds they never contributed.
+
 ## Migration notes
 
 - Do not treat this repo as part of the deployed v5-to-v6 ecosystem delta.

package/CRYPTO_ECON.md

@@ -231,7 +231,7 @@ $$M(t^+) = M(t^-) - q \cdot p \tag{10}$$
 
 The refund phase creates a *free option* for participants: they can observe late-breaking information (injury reports, market movements, team changes) and exit at zero cost. This option has value and we analyze its implications in Section 5.2.
 
-**Key property.** The refund is dollar-for-dollar: every token refunded removes exactly its mint price from the pot. Because all tiers share the uniform price $p$, the per-NFT backing ratio $B(t) / N_{\text{total}}(t) = p$ is always preserved.
+**Key property.** The refund is dollar-for-dollar: every token refunded removes exactly its mint price from the pot. Because all tiers share the uniform price $p$, the per-NFT backing ratio $B(t) / N_{\text{total}}(t) = p$ is always preserved. Reserve-minted tokens are excluded from refund eligibility — only tokens that were paid for contribute to (and may withdraw from) the pot.
 
 **World Cup example.** Two days before the tournament, a star player for Brazil suffers an injury. 300 Brazil holders refund their NFTs, reducing Brazil's count from 1,500 to 1,200 and the pot from 150 ETH to 147 ETH. The refund activity itself signals the belief shift — other participants observe the on-chain refund volume and update their expectations accordingly.
 
@@ -810,7 +810,7 @@ This is the only mechanism that provides a hard, trustless, time-bounded guarant
 
 The explicit trigger is necessary because the NO_CONTEST phase is initially a *computed* state (the view function returns it based on conditions), but the on-chain ruleset still has the scoring-phase configuration. The trigger queues a new ruleset that enables the actual cash-out mechanics.
 
-**Cash-out behavior.** During NO_CONTEST, the `computeCashOutCount` function in `DefifaHookLib` returns `cumulativeMintPrice` — the same amount the player originally paid. This is identical to the MINT/REFUND phase behavior, implementing a complete refund.
+**Cash-out behavior.** During NO_CONTEST, the `computeCashOutCount` function in `DefifaHookLib` returns `cumulativeMintPrice` — the same amount the player originally paid. This is identical to the MINT/REFUND phase behavior, implementing a complete refund. Reserve-minted tokens (those created via tier `reserveFrequency` rather than paid for) are excluded from refund calculations: their `isReserveMint` flag is set at mint time, and `beforeCashOutRecordedWith` subtracts their tier price from `cumulativeMintPrice` during MINT, REFUND, and NO_CONTEST phases. This prevents reserve beneficiaries from draining the pot by cashing out tokens they never paid for.
 
 #### 9.1.4 Priority Rules
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ballkidz/defifa",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "license": "MIT",
   "engines": {
     "node": ">=20.0.0"

package/src/DefifaDeployer.sol

@@ -53,6 +53,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
     error DefifaDeployer_InvalidFeePercent();
     error DefifaDeployer_InvalidGameConfiguration();
     error DefifaDeployer_IncorrectDecimalAmount();
+    error DefifaDeployer_InvalidCurrency();
     error DefifaDeployer_NotNoContest();
     error DefifaDeployer_NoContestAlreadyTriggered();
     error DefifaDeployer_TerminalNotFound();
@@ -337,16 +338,12 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         fulfilledCommitmentsOf[gameId] = feeAmount > 0 ? feeAmount : 1;
 
         // Send only the fee portion as payouts. The remaining balance stays as surplus for cash-outs.
+        // Use the ruleset's baseCurrency — this matches the currency under which payout limits were stored
+        // at launch time, regardless of whether the token is native ETH or an ERC-20.
         // Wrapped in try-catch so the final ruleset is always queued even if payout fails.
         // slither-disable-next-line unused-return,reentrancy-no-eth
         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: 0
+            projectId: gameId, token: token, amount: feeAmount, currency: metadata.baseCurrency, minTokensPaidOut: 0
         }) {}
         catch (bytes memory reason) {
             // Payout failed — fee stays in pot. Reset to sentinel (1) so currentGamePotOf
@@ -397,6 +394,13 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // The hook and governor hardcode uint256[128] tier-weight tables, so reject games with more than 128 tiers.
         if (launchProjectData.tiers.length > 128) revert DefifaDeployer_InvalidGameConfiguration();
 
+        // Reject ERC-20 games with a zero currency — a zero baseCurrency would cause payout limit lookups
+        // in fulfillCommitmentsOf to silently fail, skipping all commitment payouts.
+        // slither-disable-next-line incorrect-equality
+        if (launchProjectData.token.token != JBConstants.NATIVE_TOKEN && launchProjectData.token.currency == 0) {
+            revert DefifaDeployer_InvalidCurrency();
+        }
+
         // Get the game ID, optimistically knowing it will be one greater than the current count.
         // 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

package/src/DefifaHook.sol

@@ -131,6 +131,10 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// @notice The contract reporting the game pot.
     IDefifaGamePotReporter public override gamePotReporter;
 
+    /// @notice Whether a token was minted through reserves (free) rather than paid for.
+    /// @dev Reserve-minted tokens are excluded from refund calculations since no funds were contributed for them.
+    mapping(uint256 tokenId => bool) public override isReserveMint;
+
     /// @notice The currency that is accepted when minting tier NFTs.
     uint256 public override pricingCurrency;
 
@@ -289,6 +293,27 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             tokenIds: decodedTokenIds, hookStore: hookStore, hook: address(this)
         });
 
+        // During refund phases, exclude reserve-minted tokens — they were minted for free and have no paid amount
+        // to refund.
+        if (
+            gamePhase == DefifaGamePhase.MINT || gamePhase == DefifaGamePhase.REFUND
+                || gamePhase == DefifaGamePhase.NO_CONTEST
+        ) {
+            for (uint256 i; i < decodedTokenIds.length;) {
+                if (isReserveMint[decodedTokenIds[i]]) {
+                    // slither-disable-next-line calls-loop
+                    cumulativeMintPrice -= hookStore.tierOfTokenId({
+                        hook: address(this), tokenId: decodedTokenIds[i], includeResolvedUri: false
+                    })
+                    .price;
+                }
+
+                unchecked {
+                    ++i;
+                }
+            }
+        }
+
         // Use this contract as the only cash out hook.
         hookSpecifications = new JBCashOutHookSpecification[](1);
         hookSpecifications[0] =
@@ -599,6 +624,9 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             // Set the token ID.
             tokenId = tokenIds[i];
 
+            // Flag this token as reserve-minted so it is excluded from refund calculations.
+            isReserveMint[tokenId] = true;
+
             // Mint the token to the reserve beneficiary.
             // slither-disable-next-line reentrancy-no-eth
             _mint({to: reservedTokenBeneficiary, tokenId: tokenId});

package/src/interfaces/IDefifaHook.sol

@@ -162,6 +162,11 @@ interface IDefifaHook is IJB721Hook {
     /// @return The total attestation units.
     function getTierTotalAttestationUnitsOf(uint256 tier) external view returns (uint256);
 
+    /// @notice Whether a token was minted through reserves rather than paid for.
+    /// @param tokenId The ID of the token to check.
+    /// @return True if the token was minted as a reserve.
+    function isReserveMint(uint256 tokenId) external view returns (bool);
+
     /// @notice The pricing currency used by this hook.
     /// @return The currency identifier.
     function pricingCurrency() external view returns (uint256);

package/test/audit/CodexNemesisCurrencyMismatchBypass.t.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.28;
+
+import {DefifaUSDCTest} from "../DefifaUSDC.t.sol";
+import {DefifaLaunchProjectData} from "../../src/structs/DefifaLaunchProjectData.sol";
+import {DefifaTierCashOutWeight} from "../../src/structs/DefifaTierCashOutWeight.sol";
+import {DefifaTierParams} from "../../src/structs/DefifaTierParams.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
+/// @notice Regression test for the currency mismatch fix: ERC-20 games now correctly resolve payout limits via
+/// baseCurrency. Before the fix, using a non-canonical currency (e.g. currency=1 for USDC) caused sendPayoutsOf to use
+/// uint32(uint160(token)) which didn't match the stored payout limit currency, silently skipping payouts.
+/// After the fix, fulfillCommitmentsOf uses metadata.baseCurrency which always matches the stored limit.
+contract CodexNemesisCurrencyMismatchBypassTest is DefifaUSDCTest {
+    /// @notice Verify that an ERC-20 game with non-canonical currency (1) correctly pays out commitment fees.
+    function test_nonCanonicalCurrencyPayoutsNowSucceed() external {
+        uint104 tierPrice = 100e6;
+
+        (_pid, _nft, _gov) = _launch(_launchDataUsdcNonCanonical(tierPrice));
+        _users = new address[](2);
+        _users[0] = _addr(0);
+        _users[1] = _addr(1);
+
+        vm.warp(block.timestamp + 1 days + 1);
+
+        _mintUsdc(_users[0], 1, tierPrice);
+        _mintUsdc(_users[1], 2, tierPrice);
+        _delegateSelf(_users[0], 1);
+        _delegateSelf(_users[1], 2);
+
+        vm.warp(block.timestamp + 2 days);
+
+        DefifaTierCashOutWeight[] memory scorecard = new DefifaTierCashOutWeight[](2);
+        scorecard[0] = DefifaTierCashOutWeight({id: 1, cashOutWeight: _nft.TOTAL_CASHOUT_WEIGHT()});
+        scorecard[1] = DefifaTierCashOutWeight({id: 2, cashOutWeight: 0});
+
+        vm.prank(_users[1]);
+        uint256 scorecardId = _gov.submitScorecardFor(_pid, scorecard);
+
+        vm.prank(_users[1]);
+        _gov.attestToScorecardFrom(_pid, scorecardId);
+
+        vm.warp(block.timestamp + _gov.attestationGracePeriodOf(_pid) + 1);
+
+        uint256 preRatificationBalance = _balance();
+        uint256 expectedFee = (preRatificationBalance * 75_000_000) / JBConstants.SPLITS_TOTAL_PERCENT;
+
+        vm.prank(_users[1]);
+        _gov.ratifyScorecardFrom(_pid, scorecard);
+
+        // After the fix: payout succeeds, fulfilledCommitmentsOf stores the actual fee (not the sentinel).
+        assertEq(
+            deployer.fulfilledCommitmentsOf(_pid), expectedFee, "fulfilled commitments equals the expected fee amount"
+        );
+
+        // The fee has been paid out, reducing the game pot.
+        assertEq(_balance(), preRatificationBalance - expectedFee, "balance decreased by the fee amount");
+
+        // Winner cashes out and receives only the post-fee surplus, not the full pot.
+        uint256 winnerBalBefore = usdc.balanceOf(_users[0]);
+        _cashOutUsdc(_users[0], 1, 1);
+        uint256 winnerReceived = usdc.balanceOf(_users[0]) - winnerBalBefore;
+
+        assertEq(
+            winnerReceived,
+            preRatificationBalance - expectedFee,
+            "winner receives the post-fee surplus, not the full pot"
+        );
+    }
+
+    function _launchDataUsdcNonCanonical(uint104 tierPrice) internal returns (DefifaLaunchProjectData memory) {
+        DefifaTierParams[] memory tp = new DefifaTierParams[](2);
+        for (uint256 i; i < 2; i++) {
+            tp[i] = DefifaTierParams({
+                reservedRate: 1001,
+                reservedTokenBeneficiary: address(0),
+                encodedIPFSUri: bytes32(0),
+                shouldUseReservedTokenBeneficiaryAsDefault: false,
+                name: "DEFIFA"
+            });
+        }
+
+        // Non-canonical currency (1 = ETH currency ID) for a USDC token.
+        // Before the fix, this caused fulfillCommitmentsOf to silently skip payouts.
+        return DefifaLaunchProjectData({
+            name: "DEFIFA_USDC_NONCANONICAL",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            token: JBAccountingContext({token: address(usdc), decimals: 6, currency: 1}),
+            mintPeriodDuration: 1 days,
+            start: uint48(block.timestamp + 3 days),
+            refundPeriodDuration: 1 days,
+            store: new JB721TiersHookStore(),
+            splits: new JBSplit[](0),
+            attestationStartTime: 0,
+            attestationGracePeriod: 1 days,
+            defaultAttestationDelegate: address(0),
+            tierPrice: tierPrice,
+            tiers: tp,
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            minParticipation: 0,
+            scorecardTimeout: 0,
+            timelockDuration: 0
+        });
+    }
+}

package/test/audit/CodexNemesisNoContestReserveDrain.t.sol

@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.28;
+
+import {TestBaseWorkflow} from "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import {JBTest} from "@bananapus/core-v6/test/helpers/JBTest.sol";
+
+import {DefifaDeployer} from "../../src/DefifaDeployer.sol";
+import {DefifaGovernor} from "../../src/DefifaGovernor.sol";
+import {DefifaHook} from "../../src/DefifaHook.sol";
+import {DefifaTokenUriResolver} from "../../src/DefifaTokenUriResolver.sol";
+import {DefifaGamePhase} from "../../src/enums/DefifaGamePhase.sol";
+import {DefifaLaunchProjectData} from "../../src/structs/DefifaLaunchProjectData.sol";
+import {DefifaTierParams} from "../../src/structs/DefifaTierParams.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {JB721TiersMintReservesConfig} from "@bananapus/721-hook-v6/src/structs/JB721TiersMintReservesConfig.sol";
+import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBCurrencyIds} from "@bananapus/core-v6/src/libraries/JBCurrencyIds.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+import {JBRulesetConfig} from "@bananapus/core-v6/src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
+import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {IJBRulesetApprovalHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ITypeface} from "lib/typeface/contracts/interfaces/ITypeface.sol";
+
+contract CodexNemesisNoContestReserveDrainTest is JBTest, TestBaseWorkflow {
+    uint256 internal _protocolFeeProjectId;
+    uint256 internal _defifaProjectId;
+
+    DefifaDeployer internal _deployer;
+    DefifaHook internal _hookImpl;
+    DefifaGovernor internal _governorImpl;
+
+    address internal _projectOwner = address(bytes20(keccak256("projectOwner")));
+    address internal _player = address(bytes20(keccak256("player")));
+    address internal _reserveBeneficiary = address(bytes20(keccak256("reserveBeneficiary")));
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        JBAccountingContext[] memory tokens = new JBAccountingContext[](1);
+        tokens[0] = JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: JBCurrencyIds.ETH});
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        terminalConfigs[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokens});
+
+        JBRulesetConfig[] memory rulesetConfigs = new JBRulesetConfig[](1);
+        rulesetConfigs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 10 days,
+            weight: 1e18,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: JBRulesetMetadata({
+                reservedPercent: 0,
+                cashOutTaxRate: 0,
+                baseCurrency: JBCurrencyIds.ETH,
+                pausePay: false,
+                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: address(0),
+                metadata: 0
+            }),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+
+        _protocolFeeProjectId =
+            jbController().launchProjectFor(address(_projectOwner), "", rulesetConfigs, terminalConfigs, "");
+        vm.prank(_projectOwner);
+        address nanaToken =
+            address(jbController().deployERC20For(_protocolFeeProjectId, "Bananapus", "NANA", bytes32(0)));
+
+        _defifaProjectId =
+            jbController().launchProjectFor(address(_projectOwner), "", rulesetConfigs, terminalConfigs, "");
+        vm.prank(_projectOwner);
+        address defifaToken = address(jbController().deployERC20For(_defifaProjectId, "Defifa", "DEFIFA", bytes32(0)));
+
+        _hookImpl = new DefifaHook(jbDirectory(), IERC20(defifaToken), IERC20(nanaToken));
+        _governorImpl = new DefifaGovernor(jbController(), address(this));
+        _deployer = new DefifaDeployer(
+            address(_hookImpl),
+            new DefifaTokenUriResolver(ITypeface(address(0))),
+            _governorImpl,
+            jbController(),
+            new JBAddressRegistry(),
+            _defifaProjectId,
+            _protocolFeeProjectId
+        );
+
+        _hookImpl.transferOwnership(address(_deployer));
+        _governorImpl.transferOwnership(address(_deployer));
+    }
+
+    function test_noContestReserveMintExcludedFromRefund() external {
+        DefifaLaunchProjectData memory data = _launchData();
+        uint256 projectId = _deployer.launchGameWith(data);
+
+        vm.warp(data.start - data.mintPeriodDuration - data.refundPeriodDuration);
+        vm.deal(_player, 1 ether);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+        vm.prank(_player);
+        jbMultiTerminal().pay{value: 1 ether}(
+            projectId,
+            JBConstants.NATIVE_TOKEN,
+            1 ether,
+            _player,
+            0,
+            "",
+            _buildPayMetadata(abi.encode(_player, tierIds))
+        );
+
+        vm.warp(data.start + 1);
+        (, JBRulesetMetadata memory metadata) = jbController().currentRulesetOf(projectId);
+        DefifaHook hook = DefifaHook(metadata.dataHook);
+        assertEq(uint256(_deployer.currentGamePhaseOf(projectId)), uint256(DefifaGamePhase.NO_CONTEST));
+
+        JB721TiersMintReservesConfig[] memory reserveConfigs = new JB721TiersMintReservesConfig[](1);
+        reserveConfigs[0] = JB721TiersMintReservesConfig({tierId: 1, count: 1});
+        hook.mintReservesFor(reserveConfigs);
+
+        assertEq(hook.balanceOf(_reserveBeneficiary), 1, "reserve beneficiary received a free NFT");
+        assertTrue(hook.isReserveMint(_generateTokenId(1, 2)), "token flagged as reserve mint");
+
+        _deployer.triggerNoContestFor(projectId);
+
+        // Build metadata for the reserve token cashout before calling expectRevert.
+        uint256 reserveTokenId = _generateTokenId(1, 2);
+        uint256[] memory reserveTokenIds = new uint256[](1);
+        reserveTokenIds[0] = reserveTokenId;
+        bytes memory reserveCashOutMetadata = _buildCashOutMetadata(reserveTokenIds);
+
+        // The reserve beneficiary's cashout reverts — reserve-minted tokens are excluded from refund calculations.
+        vm.prank(_reserveBeneficiary);
+        vm.expectRevert();
+        jbMultiTerminal()
+            .cashOutTokensOf(
+                _reserveBeneficiary,
+                projectId,
+                0,
+                JBConstants.NATIVE_TOKEN,
+                0,
+                payable(_reserveBeneficiary),
+                reserveCashOutMetadata
+            );
+
+        // The paid player can still get their full refund.
+        uint256 playerTokenId = _generateTokenId(1, 1);
+        uint256 balanceBefore = _player.balance;
+        _cashOut(projectId, _player, playerTokenId);
+
+        // Player gets full refund (1 ether minus fee).
+        assertTrue(_player.balance > balanceBefore, "player received refund");
+        assertEq(hook.balanceOf(_player), 0, "player NFT burned");
+    }
+
+    function _cashOut(uint256 projectId, address holder, uint256 tokenId) internal {
+        uint256[] memory tokenIds = new uint256[](1);
+        tokenIds[0] = tokenId;
+        bytes memory cashOutMetadata = _buildCashOutMetadata(tokenIds);
+
+        vm.prank(holder);
+        jbMultiTerminal()
+            .cashOutTokensOf(holder, projectId, 0, JBConstants.NATIVE_TOKEN, 0, payable(holder), cashOutMetadata);
+    }
+
+    function _launchData() internal returns (DefifaLaunchProjectData memory) {
+        DefifaTierParams[] memory tierParams = new DefifaTierParams[](1);
+        tierParams[0] = DefifaTierParams({
+            reservedRate: 1,
+            reservedTokenBeneficiary: _reserveBeneficiary,
+            encodedIPFSUri: bytes32(0),
+            shouldUseReservedTokenBeneficiaryAsDefault: false,
+            name: "SOLE"
+        });
+
+        return DefifaLaunchProjectData({
+            name: "DEFIFA",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            tiers: tierParams,
+            tierPrice: 1 ether,
+            token: JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: JBCurrencyIds.ETH}),
+            mintPeriodDuration: 1 days,
+            refundPeriodDuration: 1 days,
+            start: uint48(block.timestamp + 3 days),
+            splits: new JBSplit[](0),
+            attestationStartTime: 0,
+            attestationGracePeriod: 1 days,
+            defaultAttestationDelegate: address(0),
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            store: new JB721TiersHookStore(),
+            minParticipation: 2 ether,
+            scorecardTimeout: 0,
+            timelockDuration: 0
+        });
+    }
+
+    function _buildPayMetadata(bytes memory decodedData) internal view returns (bytes memory) {
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper().getId("pay", address(_hookImpl));
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = decodedData;
+        return metadataHelper().createMetadata(ids, datas);
+    }
+
+    function _buildCashOutMetadata(uint256[] memory tokenIds) internal view returns (bytes memory) {
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper().getId("cashOut", address(_hookImpl));
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encode(tokenIds);
+        return metadataHelper().createMetadata(ids, datas);
+    }
+
+    function _generateTokenId(uint256 tierId, uint256 tokenNumber) internal pure returns (uint256) {
+        return (tierId * 1_000_000_000) + tokenNumber;
+    }
+}

package/test/audit/CurrencyMismatchFix.t.sol

@@ -0,0 +1,265 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.28;
+
+import {DefifaUSDCTest, DefifaMockUSDC} from "../DefifaUSDC.t.sol";
+import {DefifaDeployer} from "../../src/DefifaDeployer.sol";
+import {DefifaGovernor} from "../../src/DefifaGovernor.sol";
+import {DefifaHook} from "../../src/DefifaHook.sol";
+import {DefifaTokenUriResolver} from "../../src/DefifaTokenUriResolver.sol";
+import {DefifaLaunchProjectData} from "../../src/structs/DefifaLaunchProjectData.sol";
+import {DefifaTierCashOutWeight} from "../../src/structs/DefifaTierCashOutWeight.sol";
+import {DefifaTierParams} from "../../src/structs/DefifaTierParams.sol";
+import {DefifaDelegation} from "../../src/structs/DefifaDelegation.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
+import {IJBRulesetApprovalHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBRulesetConfig, JBTerminalConfig} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBCurrencyIds} from "@bananapus/core-v6/src/libraries/JBCurrencyIds.sol";
+import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import {JBMultiTerminal} from "@bananapus/core-v6/src/JBMultiTerminal.sol";
+import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
+import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
+import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
+import {JBRulesetMetadataResolver} from "@bananapus/core-v6/src/libraries/JBRulesetMetadataResolver.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+import {TestBaseWorkflow} from "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import {JBTest} from "@bananapus/core-v6/test/helpers/JBTest.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ITypeface} from "lib/typeface/contracts/interfaces/ITypeface.sol";
+
+/// @title CurrencyMismatchFixTest
+/// @notice Adversarial tests for the currency mismatch fix: verifies that fulfillCommitmentsOf correctly resolves
+/// payout limits for both ETH and ERC-20 games, and that launch-time validation rejects zero-currency ERC-20
+/// configurations. Inherits DefifaUSDCTest for USDC helpers and fee project setup.
+contract CurrencyMismatchFixTest is DefifaUSDCTest {
+    // =========================================================================
+    // HELPERS
+    // =========================================================================
+
+    function _launchDataNonCanonical(uint8 n, uint104 tierPrice) internal returns (DefifaLaunchProjectData memory) {
+        DefifaTierParams[] memory tp = new DefifaTierParams[](n);
+        for (uint256 i; i < n; i++) {
+            tp[i] = DefifaTierParams({
+                reservedRate: 1001,
+                reservedTokenBeneficiary: address(0),
+                encodedIPFSUri: bytes32(0),
+                shouldUseReservedTokenBeneficiaryAsDefault: false,
+                name: "DEFIFA"
+            });
+        }
+
+        // Non-canonical currency (1) for a USDC token.
+        return DefifaLaunchProjectData({
+            name: "DEFIFA_NONCANONICAL",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            token: JBAccountingContext({token: address(usdc), decimals: 6, currency: 1}),
+            mintPeriodDuration: 1 days,
+            start: uint48(block.timestamp + 3 days),
+            refundPeriodDuration: 1 days,
+            store: new JB721TiersHookStore(),
+            splits: new JBSplit[](0),
+            attestationStartTime: 0,
+            attestationGracePeriod: 1 days,
+            defaultAttestationDelegate: address(0),
+            tierPrice: tierPrice,
+            tiers: tp,
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            minParticipation: 0,
+            scorecardTimeout: 0,
+            timelockDuration: 0
+        });
+    }
+
+    function _setupNonCanonicalGame(uint8 nTiers, uint104 tierPrice) internal {
+        DefifaLaunchProjectData memory d = _launchDataNonCanonical(nTiers, tierPrice);
+        (_pid, _nft, _gov) = _launch(d);
+        vm.warp(d.start - d.mintPeriodDuration - d.refundPeriodDuration);
+        _users = new address[](nTiers);
+        for (uint256 i; i < nTiers; i++) {
+            _users[i] = _addr(i);
+            _mintUsdc(_users[i], i + 1, tierPrice);
+            _delegateSelf(_users[i], i + 1);
+            vm.warp(block.timestamp + 1);
+        }
+    }
+
+    // =========================================================================
+    // TEST 1: ERC-20 game with non-canonical currency correctly resolves payout limit
+    // =========================================================================
+
+    /// @notice An ERC-20 game launched with currency=1 (non-canonical) now correctly sends commitment payouts
+    /// because fulfillCommitmentsOf uses metadata.baseCurrency instead of uint32(uint160(token)).
+    function test_currencyMismatchFix_erc20NonCanonicalCurrencyFulfillsCorrectly() external {
+        uint104 tierPrice = 100e6;
+        _setupNonCanonicalGame(4, tierPrice);
+
+        // Advance to scoring phase.
+        _toScoring();
+
+        uint256 potBefore = _balance();
+        assertEq(potBefore, 400e6, "pot = 400 USDC before fulfillment");
+
+        uint256 expectedFee = (potBefore * 75_000_000) / JBConstants.SPLITS_TOTAL_PERCENT;
+
+        _attestAndRatify(_evenScorecard(4));
+
+        // Verify: payout succeeded. fulfilledCommitmentsOf stores the actual fee amount, not sentinel (1).
+        uint256 fulfilled = deployer.fulfilledCommitmentsOf(_pid);
+        assertEq(fulfilled, expectedFee, "fulfilled = expected fee (payout succeeded)");
+
+        // Verify: balance reduced by the fee.
+        assertEq(_balance(), potBefore - expectedFee, "balance = pot - fee");
+    }
+
+    // =========================================================================
+    // TEST 2: ETH game fulfillment still works correctly (no regression)
+    // =========================================================================
+
+    /// @notice ETH game (canonical currency) continues to work after the fix.
+    /// Covered by DefifaFeeAccountingTest; this verifies no regression from the baseCurrency change.
+    function test_currencyMismatchFix_ethGameFeeAccountingUnchanged() external {
+        // The DefifaFeeAccountingTest suite tests ETH fulfillment comprehensively.
+        // Here we verify the core assertion: fee percentage matches for USDC canonical game too.
+        uint104 tierPrice = 100e6;
+        _setupGameUsdc(4, tierPrice);
+
+        _toScoring();
+
+        uint256 potBefore = _balance();
+        uint256 expectedFee = (potBefore * 75_000_000) / JBConstants.SPLITS_TOTAL_PERCENT;
+
+        _attestAndRatify(_evenScorecard(4));
+
+        uint256 fulfilled = deployer.fulfilledCommitmentsOf(_pid);
+        assertEq(fulfilled, expectedFee, "canonical USDC fee unchanged by fix");
+        assertEq(fulfilled + _balance(), potBefore, "fee + surplus = original pot");
+    }
+
+    // =========================================================================
+    // TEST 3: Non-canonical ERC-20 winner cash-out is correct after fulfillment
+    // =========================================================================
+
+    /// @notice After the fix, the winner of a non-canonical-currency ERC-20 game receives the post-fee surplus
+    /// (not the full pot). This confirms the fee was actually deducted.
+    function test_currencyMismatchFix_winnerReceivesPostFeeSurplusNotFullPot() external {
+        uint104 tierPrice = 100e6;
+        _setupNonCanonicalGame(2, tierPrice);
+
+        _toScoring();
+
+        uint256 potBefore = _balance();
+        uint256 expectedFee = (potBefore * 75_000_000) / JBConstants.SPLITS_TOTAL_PERCENT;
+
+        // Tier 1 gets 100% of the cashout weight.
+        DefifaTierCashOutWeight[] memory sc = new DefifaTierCashOutWeight[](2);
+        sc[0] = DefifaTierCashOutWeight({id: 1, cashOutWeight: _nft.TOTAL_CASHOUT_WEIGHT()});
+        sc[1] = DefifaTierCashOutWeight({id: 2, cashOutWeight: 0});
+        _attestAndRatify(sc);
+
+        // Fulfillment succeeded -- fee was deducted.
+        assertEq(deployer.fulfilledCommitmentsOf(_pid), expectedFee, "fee was deducted");
+
+        // Winner cashes out and receives the post-fee surplus.
+        uint256 winnerBalBefore = usdc.balanceOf(_users[0]);
+        _cashOutUsdc(_users[0], 1, 1);
+        uint256 winnerReceived = usdc.balanceOf(_users[0]) - winnerBalBefore;
+
+        // Before the fix, winner would have received the full pot (fee was skipped).
+        // After the fix, winner receives pot minus fee.
+        assertEq(winnerReceived, potBefore - expectedFee, "winner receives post-fee surplus, not the full pot");
+        assertLt(winnerReceived, potBefore, "winner does NOT receive the full pot");
+    }
+
+    // =========================================================================
+    // TEST 4: Launch rejects zero currency for non-native tokens
+    // =========================================================================
+
+    /// @notice Launching an ERC-20 game with currency=0 is rejected at launch time.
+    function test_currencyMismatchFix_revertOnZeroCurrencyForErc20() external {
+        DefifaTierParams[] memory tp = new DefifaTierParams[](2);
+        for (uint256 i; i < 2; i++) {
+            tp[i] = DefifaTierParams({
+                reservedRate: 1001,
+                reservedTokenBeneficiary: address(0),
+                encodedIPFSUri: bytes32(0),
+                shouldUseReservedTokenBeneficiaryAsDefault: false,
+                name: "DEFIFA"
+            });
+        }
+
+        DefifaLaunchProjectData memory d = DefifaLaunchProjectData({
+            name: "DEFIFA_ZERO_CURRENCY",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            token: JBAccountingContext({token: address(usdc), decimals: 6, currency: 0}),
+            mintPeriodDuration: 1 days,
+            start: uint48(block.timestamp + 3 days),
+            refundPeriodDuration: 1 days,
+            store: new JB721TiersHookStore(),
+            splits: new JBSplit[](0),
+            attestationStartTime: 0,
+            attestationGracePeriod: 1 days,
+            defaultAttestationDelegate: address(0),
+            tierPrice: 100e6,
+            tiers: tp,
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            minParticipation: 0,
+            scorecardTimeout: 0,
+            timelockDuration: 0
+        });
+
+        vm.expectRevert(abi.encodeWithSignature("DefifaDeployer_InvalidCurrency()"));
+        deployer.launchGameWith(d);
+    }
+
+    /// @notice Native token (ETH) is exempt from the zero-currency check.
+    function test_currencyMismatchFix_nativeTokenAllowsAnyCurrency() external {
+        DefifaTierParams[] memory tp = new DefifaTierParams[](2);
+        for (uint256 i; i < 2; i++) {
+            tp[i] = DefifaTierParams({
+                reservedRate: 1001,
+                reservedTokenBeneficiary: address(0),
+                encodedIPFSUri: bytes32(0),
+                shouldUseReservedTokenBeneficiaryAsDefault: false,
+                name: "DEFIFA"
+            });
+        }
+
+        DefifaLaunchProjectData memory d = DefifaLaunchProjectData({
+            name: "DEFIFA_ETH_LAUNCH",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            token: JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: JBCurrencyIds.ETH}),
+            mintPeriodDuration: 1 days,
+            start: uint48(block.timestamp + 3 days),
+            refundPeriodDuration: 1 days,
+            store: new JB721TiersHookStore(),
+            splits: new JBSplit[](0),
+            attestationStartTime: 0,
+            attestationGracePeriod: 1 days,
+            defaultAttestationDelegate: address(0),
+            tierPrice: 1 ether,
+            tiers: tp,
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            minParticipation: 0,
+            scorecardTimeout: 0,
+            timelockDuration: 0
+        });
+
+        // Should succeed without revert.
+        uint256 gameId = deployer.launchGameWith(d);
+        assertGt(gameId, 0, "ETH game launched successfully");
+    }
+}