@ballkidz/defifa 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ballkidz/defifa",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "engines": {
     "node": ">=20.0.0"
@@ -13,10 +13,10 @@
     "url": "https://github.com/BallKidz/defifa-collection-deployer"
   },
   "dependencies": {
-    "@bananapus/721-hook-v6": "^0.0.8",
-    "@bananapus/address-registry-v6": "^0.0.3",
-    "@bananapus/core-v6": "^0.0.6",
-    "@bananapus/permission-ids-v6": "^0.0.3",
+    "@bananapus/721-hook-v6": "^0.0.9",
+    "@bananapus/address-registry-v6": "^0.0.4",
+    "@bananapus/core-v6": "^0.0.9",
+    "@bananapus/permission-ids-v6": "^0.0.4",
     "@openzeppelin/contracts": "5.2.0",
     "@prb/math": "^4.1.1",
     "scripty.sol": "^2.1.1"

package/src/DefifaDeployer.sol

@@ -311,6 +311,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
                 uint48(block.timestamp + launchProjectData.mintPeriodDuration + launchProjectData.refundPeriodDuration);
         }
         // Start minting right away if a start time isn't provided.
+        // slither-disable-next-line incorrect-equality
         else if (
             launchProjectData.mintPeriodDuration == 0
                 && launchProjectData.start > block.timestamp + launchProjectData.refundPeriodDuration

package/src/DefifaGovernor.sol

@@ -127,6 +127,10 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
     /// @param gameId The ID of the game to get a proposal state of.
     /// @param scorecardId The ID of the proposal to get the state of.
     /// @return The state.
+    /// @dev Boundary semantics (inclusive):
+    ///   - At exactly `attestationsBegin`, the state transitions from PENDING to ACTIVE (attestations are open).
+    ///   - At exactly `gracePeriodEnds`, the grace period has elapsed and the state transitions from ACTIVE to
+    ///     SUCCEEDED (if quorum is met) or remains ACTIVE (if not).
     function stateOf(uint256 gameId, uint256 scorecardId) public view virtual override returns (DefifaScorecardState) {
         // Keep a reference to the ratified scorecard ID.
         uint256 _ratifiedScorecardId = ratifiedScorecardIdOf[gameId];
@@ -147,12 +151,14 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         }
 
         // If the scorecard has attestations beginning in the future, the state is PENDING.
-        if (_scorecard.attestationsBegin >= block.timestamp) {
+        // At exactly `attestationsBegin`, attestations are open so the state is ACTIVE.
+        if (_scorecard.attestationsBegin > block.timestamp) {
             return DefifaScorecardState.PENDING;
         }
 
-        // If the scorecard has a grace period expiring in the future, the state is ACTIVE.
-        if (_scorecard.gracePeriodEnds >= block.timestamp) {
+        // If the scorecard's grace period has not yet ended, the state is ACTIVE.
+        // At exactly `gracePeriodEnds`, the grace period has elapsed so we fall through to the quorum check.
+        if (_scorecard.gracePeriodEnds > block.timestamp) {
             return DefifaScorecardState.ACTIVE;
         }
 
@@ -363,8 +369,12 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         uint256 _timeUntilAttestationsBegin =
             block.timestamp > _attestationStartTime ? 0 : _attestationStartTime - block.timestamp;
 
-        _scorecard.attestationsBegin = uint48(block.timestamp + _timeUntilAttestationsBegin);
-        _scorecard.gracePeriodEnds = uint48(block.timestamp + attestationGracePeriodOf(_gameId));
+        uint48 _attestationsBegin = uint48(block.timestamp + _timeUntilAttestationsBegin);
+        _scorecard.attestationsBegin = _attestationsBegin;
+        // Grace period extends from when attestations begin, not from submission time.
+        // This prevents the grace period from expiring before attestations even start
+        // when a scorecard is submitted early.
+        _scorecard.gracePeriodEnds = uint48(_attestationsBegin + attestationGracePeriodOf(_gameId));
 
         // Keep a reference to the default attestation delegate.
         address _defaultAttestationDelegate = IDefifaHook(_metadata.dataHook).defaultAttestationDelegate();
@@ -459,8 +469,13 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // slither-disable-next-line unused-return
         Address.verifyCallResult({success: success, returndata: returndata});
 
-        // Fulfill any commitments for the game.
-        IDefifaDeployer(controller.PROJECTS().ownerOf(gameId)).fulfillCommitmentsOf(gameId);
+        // Fulfill any commitments for the game. Wrapped in try-catch so that a fulfillment
+        // failure (e.g. from sendPayoutsOf reverting) does not permanently block ratification.
+        // Fulfillment can be retried separately by calling fulfillCommitmentsOf directly.
+        try IDefifaDeployer(controller.PROJECTS().ownerOf(gameId)).fulfillCommitmentsOf(gameId) {}
+        catch (bytes memory reason) {
+            emit FulfillmentFailed(gameId, reason);
+        }
 
         emit ScorecardRatified(gameId, scorecardId, msg.sender);
     }

package/src/DefifaHook.sol

@@ -54,7 +54,6 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     error DefifaHook_NothingToClaim();
     error DefifaHook_NothingToMint();
     error DefifaHook_WrongCurrency();
-    error DefifaHook_NoContest();
     error DefifaHook_Overspending();
     error DefifaHook_CashoutWeightsAlreadySet();
     error DefifaHook_ReservedTokenMintingPaused();
@@ -610,11 +609,6 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // Make sure the cashOut weights haven't already been set.
         if (cashOutWeightIsSet) revert DefifaHook_CashoutWeightsAlreadySet();
 
-        // Make sure the game is not in no contest.
-        if (_gamePhase == DefifaGamePhase.NO_CONTEST) {
-            revert DefifaHook_NoContest();
-        }
-
         // Validate weights and build the array. Reverts on invalid input.
         _tierCashOutWeights =
             DefifaHookLib.validateAndBuildWeights({tierWeights: tierWeights, _store: store, hook: address(this)});

package/src/interfaces/IDefifaGovernor.sol

@@ -24,6 +24,8 @@ interface IDefifaGovernor {
 
     event ScorecardRatified(uint256 indexed gameId, uint256 indexed scorecardId, address caller);
 
+    event FulfillmentFailed(uint256 indexed gameId, bytes reason);
+
     /// @notice The maximum tier ID that contributes attestation power.
     /// @return The maximum attestation power tier.
     function MAX_ATTESTATION_POWER_TIER() external view returns (uint256);

package/test/regression/M35_GracePeriodBypass.t.sol

@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+import "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+
+import {DefifaGovernor} from "../../src/DefifaGovernor.sol";
+import {DefifaDeployer} from "../../src/DefifaDeployer.sol";
+import {DefifaHook} from "../../src/DefifaHook.sol";
+import {DefifaTokenUriResolver} from "../../src/DefifaTokenUriResolver.sol";
+import {DefifaScorecardState} from "../../src/enums/DefifaScorecardState.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+
+import {JBMetadataResolver} from "@bananapus/core-v6/src/libraries/JBMetadataResolver.sol";
+import {MetadataResolverHelper} from "@bananapus/core-v6/test/helpers/MetadataResolverHelper.sol";
+import {JBTest} from "@bananapus/core-v6/test/helpers/JBTest.sol";
+import {JBRulesetMetadataResolver} from "@bananapus/core-v6/src/libraries/JBRulesetMetadataResolver.sol";
+import {
+    JB721TiersRulesetMetadataResolver
+} from "@bananapus/721-hook-v6/src/libraries/JB721TiersRulesetMetadataResolver.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ITypeface} from "lib/typeface/contracts/interfaces/ITypeface.sol";
+import {IJB721TokenUriResolver} from "@bananapus/721-hook-v6/src/interfaces/IJB721TokenUriResolver.sol";
+import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {DefifaDelegation} from "../../src/structs/DefifaDelegation.sol";
+import {DefifaLaunchProjectData} from "../../src/structs/DefifaLaunchProjectData.sol";
+import {DefifaTierParams} from "../../src/structs/DefifaTierParams.sol";
+import {DefifaTierCashOutWeight} from "../../src/structs/DefifaTierCashOutWeight.sol";
+
+/// @dev Helper to read block.timestamp via an external call, bypassing the via-ir optimizer's timestamp caching.
+contract TimestampReader2 {
+    function timestamp() external view returns (uint256) {
+        return block.timestamp;
+    }
+}
+
+/// @title M35_GracePeriodBypass
+/// @notice Regression test: grace period should extend from attestation start, not submission time.
+///         When a scorecard is submitted early (before attestationStartTime), the grace period
+///         must not expire before attestations begin.
+contract M35_GracePeriodBypass is JBTest, TestBaseWorkflow {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    TimestampReader2 private _tsReader = new TimestampReader2();
+
+    address _protocolFeeProjectTokenAccount;
+    address _defifaProjectTokenAccount;
+    uint256 _protocolFeeProjectId;
+    uint256 _defifaProjectId;
+    uint256 _gameId = 3;
+
+    DefifaDeployer deployer;
+    DefifaHook hook;
+    DefifaGovernor governor;
+
+    address projectOwner = address(bytes20(keccak256("projectOwner")));
+
+    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);
+        _protocolFeeProjectTokenAccount =
+            address(jbController().deployERC20For(_protocolFeeProjectId, "Bananapus", "NANA", bytes32(0)));
+
+        _defifaProjectId =
+            jbController().launchProjectFor(address(projectOwner), "", rulesetConfigs, terminalConfigs, "");
+        vm.prank(projectOwner);
+        _defifaProjectTokenAccount =
+            address(jbController().deployERC20For(_defifaProjectId, "Defifa", "DEFIFA", bytes32(0)));
+
+        hook = new DefifaHook(
+            jbDirectory(), IERC20(address(_defifaProjectTokenAccount)), IERC20(_protocolFeeProjectTokenAccount)
+        );
+        governor = new DefifaGovernor(jbController(), address(this));
+        JBAddressRegistry _registry = new JBAddressRegistry();
+        DefifaTokenUriResolver _tokenURIResolver = new DefifaTokenUriResolver(ITypeface(address(0)));
+        deployer = new DefifaDeployer(
+            address(hook),
+            _tokenURIResolver,
+            governor,
+            jbController(),
+            _registry,
+            _defifaProjectId,
+            _protocolFeeProjectId
+        );
+
+        hook.transferOwnership(address(deployer));
+        governor.transferOwnership(address(deployer));
+    }
+
+    /// @notice Test that grace period extends from attestation start, not submission time.
+    /// @dev With the fix, a scorecard submitted early should have its grace period start after
+    ///      attestationsBegin, ensuring the grace period doesn't expire before attestations start.
+    function test_gracePeriodExtendsFromAttestationStart() public {
+        uint8 nTiers = 4;
+        address[] memory _users = new address[](nTiers);
+
+        // Set attestation start time far in the future (e.g. block.timestamp + 10 days)
+        // Grace period of 1 day
+        uint256 futureAttestationStart = block.timestamp + 10 days;
+        uint256 gracePeriod = 1 days;
+
+        DefifaLaunchProjectData memory defifaData =
+            _getBasicLaunchDataWithAttestationTiming(nTiers, futureAttestationStart, gracePeriod);
+        (uint256 _projectId, DefifaHook _nft, DefifaGovernor _governor) = _createProject(defifaData);
+
+        // Phase 1: Mint
+        vm.warp(defifaData.start - defifaData.mintPeriodDuration - defifaData.refundPeriodDuration);
+        for (uint256 i = 0; i < nTiers; i++) {
+            _users[i] = address(bytes20(keccak256(abi.encode("user", Strings.toString(i)))));
+            vm.deal(_users[i], 1 ether);
+
+            uint16[] memory rawMetadata = new uint16[](1);
+            rawMetadata[0] = uint16(i + 1);
+            bytes memory metadata = _buildPayMetadata(abi.encode(_users[i], rawMetadata));
+
+            vm.prank(_users[i]);
+            jbMultiTerminal().pay{value: 1 ether}(
+                _projectId, JBConstants.NATIVE_TOKEN, 1 ether, _users[i], 0, "", metadata
+            );
+
+            DefifaDelegation[] memory delegations = new DefifaDelegation[](1);
+            delegations[0] = DefifaDelegation({delegatee: _users[i], tierId: uint256(i + 1)});
+            vm.prank(_users[i]);
+            _nft.setTierDelegatesTo(delegations);
+
+            vm.warp(_tsReader.timestamp() + 1);
+        }
+
+        // Warp to scoring phase
+        vm.warp(defifaData.start + 1);
+
+        // Submit scorecard early (attestation start time is still in the future)
+        DefifaTierCashOutWeight[] memory scorecards = new DefifaTierCashOutWeight[](nTiers);
+        uint256 weightPerTier = _nft.TOTAL_CASHOUT_WEIGHT() / nTiers;
+        uint256 assigned;
+        for (uint256 i = 0; i < nTiers; i++) {
+            scorecards[i].id = i + 1;
+            scorecards[i].cashOutWeight = weightPerTier;
+            assigned += weightPerTier;
+        }
+        if (assigned < _nft.TOTAL_CASHOUT_WEIGHT()) {
+            scorecards[0].cashOutWeight += _nft.TOTAL_CASHOUT_WEIGHT() - assigned;
+        }
+
+        uint256 submissionTime = _tsReader.timestamp();
+        uint256 _proposalId = _governor.submitScorecardFor(_gameId, scorecards);
+
+        // The scorecard should be PENDING (attestations haven't started yet)
+        assertEq(
+            uint256(_governor.stateOf(_gameId, _proposalId)),
+            uint256(DefifaScorecardState.PENDING),
+            "Scorecard should be PENDING before attestation start"
+        );
+
+        // Key assertion: warp past the old grace period end (submissionTime + gracePeriod)
+        // but BEFORE attestations begin. The scorecard should still be PENDING, NOT in a post-grace state.
+        vm.warp(submissionTime + gracePeriod + 1);
+
+        // With the fix, the scorecard should still be PENDING because attestationsBegin hasn't arrived yet.
+        assertEq(
+            uint256(_governor.stateOf(_gameId, _proposalId)),
+            uint256(DefifaScorecardState.PENDING),
+            "Scorecard should still be PENDING even after old grace period would have ended"
+        );
+
+        // Now warp to after attestation start (attestation begin + 1)
+        vm.warp(futureAttestationStart + 1);
+
+        // Now the scorecard should be ACTIVE (attestations are open and grace period hasn't ended yet)
+        assertEq(
+            uint256(_governor.stateOf(_gameId, _proposalId)),
+            uint256(DefifaScorecardState.ACTIVE),
+            "Scorecard should be ACTIVE after attestation start but before grace period ends"
+        );
+
+        // Warp to after attestation start + grace period
+        vm.warp(futureAttestationStart + gracePeriod + 1);
+
+        // Now grace period has truly ended, so the state should be ACTIVE (quorum not met)
+        // The key here is that it transitioned properly - grace period ran from attestation start
+        assertEq(
+            uint256(_governor.stateOf(_gameId, _proposalId)),
+            uint256(DefifaScorecardState.ACTIVE),
+            "Scorecard should be ACTIVE (no quorum) after grace period truly ends"
+        );
+    }
+
+    // ----- Internal helpers ------
+
+    function _getBasicLaunchDataWithAttestationTiming(
+        uint8 nTiers,
+        uint256 attestationStartTime,
+        uint256 attestationGracePeriod
+    )
+        internal
+        returns (DefifaLaunchProjectData memory)
+    {
+        DefifaTierParams[] memory tierParams = new DefifaTierParams[](nTiers);
+        for (uint256 i = 0; i < nTiers; i++) {
+            tierParams[i] = DefifaTierParams({
+                reservedRate: 1001,
+                reservedTokenBeneficiary: address(0),
+                encodedIPFSUri: bytes32(0),
+                shouldUseReservedTokenBeneficiaryAsDefault: false,
+                name: "DEFIFA"
+            });
+        }
+
+        return DefifaLaunchProjectData({
+            name: "DEFIFA",
+            projectUri: "",
+            contractUri: "",
+            baseUri: "",
+            tierPrice: 1 ether,
+            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: attestationStartTime,
+            attestationGracePeriod: attestationGracePeriod,
+            defaultAttestationDelegate: address(0),
+            tiers: tierParams,
+            defaultTokenUriResolver: IJB721TokenUriResolver(address(0)),
+            terminal: jbMultiTerminal(),
+            minParticipation: 0,
+            scorecardTimeout: 0
+        });
+    }
+
+    function _createProject(DefifaLaunchProjectData memory defifaLaunchData)
+        internal
+        returns (uint256 projectId, DefifaHook nft, DefifaGovernor _governor)
+    {
+        _governor = governor;
+        (projectId) = deployer.launchGameWith(defifaLaunchData);
+        JBRuleset memory _fc = jbRulesets().currentOf(projectId);
+        if (_fc.dataHook() == address(0)) {
+            (_fc,) = jbRulesets().latestQueuedOf(projectId);
+        }
+        nft = DefifaHook(_fc.dataHook());
+    }
+
+    function _buildPayMetadata(bytes memory metadata) internal returns (bytes memory) {
+        bytes[] memory data = new bytes[](1);
+        data[0] = metadata;
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper().getId("pay", address(hook));
+        return metadataHelper().createMetadata(ids, data);
+    }
+}