Add block number minting cutoff

Author: ThunderDeliverer

foundry.toml

@@ -6,5 +6,5 @@ solc = "0.8.30"
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
 optimizer = true
-optimizer_runs = 200
+optimizer_runs = 800
 via_ir = true

src/Fraxiversarry.sol

@@ -59,6 +59,7 @@ contract Fraxiversarry is
     uint256 public giftMintingLimit;
     uint256 public giftMintingPrice;
     uint256 public mintingFeeBasisPoints;
+    uint256 public mintingCutoffBlock;
 
     bool private _isBridgeOperation;
 
@@ -83,6 +84,7 @@ contract Fraxiversarry is
         nextGiftTokenId = mintingLimit;
         nextPremiumTokenId = mintingLimit + giftMintingLimit;
         mintingFeeBasisPoints = 25; // 0.25%
+        mintingCutoffBlock = block.number + (35 days / 2 seconds); // Approximately 5 weeks with 2s blocktime
 
         //TODO: Set correct URIs
         giftTokenUri = "https://gift.tba.frax/";
@@ -102,6 +104,7 @@ contract Fraxiversarry is
     }
 
     function paidMint(address erc20Contract) public returns (uint256) {
+        if (block.number > mintingCutoffBlock) revert MintingPeriodOver();
         if (nextTokenId >= mintingLimit) revert MintingLimitReached();
         if (mintPrices[erc20Contract] == 0) revert UnsupportedToken();
 
@@ -122,6 +125,7 @@ contract Fraxiversarry is
     }
 
     function giftMint(address recipient) public returns (uint256) {
+        if (block.number > mintingCutoffBlock) revert MintingPeriodOver();
         if (nextGiftTokenId >= mintingLimit + giftMintingLimit) revert GiftMintingLimitReached();
 
         uint256 tokenId = nextGiftTokenId;
@@ -311,6 +315,14 @@ contract Fraxiversarry is
         emit MintingFeeUpdated(previousFeeBasisPoints, newFeeBasisPoints);
     }
 
+    function updateMintingCutoffBlock(uint256 newCutoffBlock) public onlyOwner {
+        uint256 previousCutoffBlock = mintingCutoffBlock;
+
+        mintingCutoffBlock = newCutoffBlock;
+
+        emit MintingCutoffBlockUpdated(previousCutoffBlock, newCutoffBlock);
+    }
+
     function retrieveCollectedFees(address erc20Contract, address to) public onlyOwner {
         uint256 feeAmount = collectedFees[erc20Contract];
         if (feeAmount == 0) return;

src/interfaces/IFraxiversarryErrors.sol

@@ -12,6 +12,7 @@ contract IFraxiversarryErrors {
     error InvalidGiftMintPrice();
     error InvalidRange();
     error MintingLimitReached();
+    error MintingPeriodOver();
     error MissingComposedMessage();
     error OnlyTokenOwnerCanBurnTheToken();
     error OnlyTokenOwnerCanFuseTokens();

src/interfaces/IFraxiversarryEvents.sol

@@ -10,6 +10,8 @@ contract IFraxiversarryEvents {
 
     event GiftMintPriceUpdated(uint256 previousMintPrice, uint256 newMintPrice);
 
+    event MintingCutoffBlockUpdated(uint256 previousCutoffBlock, uint256 newCutoffBlock);
+
     event MintingFeeUpdated(uint256 previousFeeBasisPoints, uint256 newFeeBasisPoints);
 
     event MintPriceUpdated(address indexed erc20Contract, uint256 previousMintPrice, uint256 newMintPrice);

test/Fraxiversarry.t.sol

@@ -1519,6 +1519,112 @@ contract FraxiversarryTest is Test, IFraxiversarryErrors, IFraxiversarryEvents {
         fraxiversarry.tokenURI(tokenId);
     }
 
+    // ----------------------------------------------------------
+    // Minting cutoff block tests
+    // ----------------------------------------------------------
+
+    function testConstructorSetsMintingCutoffBlockRelativeToDeployBlock() public {
+        // Redeploy locally to assert constructor math precisely
+        MockLzEndpoint localEndpoint = new MockLzEndpoint();
+
+        uint256 deployBlock = block.number;
+        Fraxiversarry local = new Fraxiversarry(owner, address(localEndpoint));
+
+        uint256 expectedDelta = (35 days / 2 seconds);
+        assertEq(local.mintingCutoffBlock(), deployBlock + expectedDelta);
+    }
+
+    function testPaidMintAllowedAtCutoffBlock() public {
+        // Set cutoff to current block so mint is still allowed
+        vm.prank(owner);
+        fraxiversarry.updateMintingCutoffBlock(block.number);
+
+        _approveWithFee(alice, wfrax);
+
+        vm.prank(alice);
+        uint256 tokenId = fraxiversarry.paidMint(address(wfrax));
+
+        assertEq(fraxiversarry.ownerOf(tokenId), alice);
+        assertEq(uint256(fraxiversarry.tokenTypes(tokenId)), uint256(Fraxiversarry.TokenType.BASE));
+    }
+
+    function testPaidMintRevertsAfterCutoffBlock() public {
+        uint256 cutoff = block.number;
+        vm.prank(owner);
+        fraxiversarry.updateMintingCutoffBlock(cutoff);
+
+        // Move to cutoff + 1
+        vm.roll(cutoff + 1);
+
+        _approveWithFee(alice, wfrax);
+
+        vm.prank(alice);
+        vm.expectRevert(MintingPeriodOver.selector);
+        fraxiversarry.paidMint(address(wfrax));
+    }
+
+    function testGiftMintAllowedAtCutoffBlock() public {
+        vm.prank(owner);
+        fraxiversarry.updateMintingCutoffBlock(block.number);
+
+        (,, uint256 giftMintingPrice) = fraxiversarry.getGiftMintingPriceWithFee();
+        vm.prank(alice);
+        wfrax.approve(address(fraxiversarry), giftMintingPrice);
+
+        vm.prank(alice);
+        uint256 tokenId = fraxiversarry.giftMint(bob);
+
+        assertEq(fraxiversarry.ownerOf(tokenId), bob);
+        assertEq(uint256(fraxiversarry.tokenTypes(tokenId)), uint256(Fraxiversarry.TokenType.GIFT));
+    }
+
+    function testGiftMintRevertsAfterCutoffBlock() public {
+        uint256 cutoff = block.number;
+        vm.prank(owner);
+        fraxiversarry.updateMintingCutoffBlock(cutoff);
+
+        vm.roll(cutoff + 1);
+
+        (,, uint256 giftMintingPrice) = fraxiversarry.getGiftMintingPriceWithFee();
+        vm.prank(alice);
+        wfrax.approve(address(fraxiversarry), giftMintingPrice);
+
+        vm.prank(alice);
+        vm.expectRevert(MintingPeriodOver.selector);
+        fraxiversarry.giftMint(bob);
+    }
+
+    function testUpdateMintingCutoffBlockOnlyOwner() public {
+        vm.prank(alice);
+        vm.expectRevert(); // Ownable: caller is not the owner
+        fraxiversarry.updateMintingCutoffBlock(block.number + 100);
+    }
+
+    function testUpdateMintingCutoffBlockEmitsEvent() public {
+        uint256 previous = fraxiversarry.mintingCutoffBlock();
+        uint256 next = previous + 123;
+
+        vm.recordLogs();
+        vm.prank(owner);
+        fraxiversarry.updateMintingCutoffBlock(next);
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+
+        bytes32 expectedSig = keccak256("MintingCutoffBlockUpdated(uint256,uint256)");
+        bool found;
+
+        for (uint256 i; i < logs.length; ++i) {
+            if (logs[i].topics[0] == expectedSig) {
+                found = true;
+                (uint256 loggedPrev, uint256 loggedNext) = abi.decode(logs[i].data, (uint256, uint256));
+                assertEq(loggedPrev, previous);
+                assertEq(loggedNext, next);
+            }
+        }
+
+        assertTrue(found, "MintingCutoffBlockUpdated event not found");
+        assertEq(fraxiversarry.mintingCutoffBlock(), next);
+    }
+
     // ----------------------------------------------------------
     // ONFT view helpers (token() / approvalRequired())
     // ----------------------------------------------------------