supply royalty

.gitignore

@@ -9,4 +9,4 @@ cache
 .env.*
 dist/
 .idea
-broadcast
+broadcast/

.storage-layout

@@ -30,6 +30,7 @@
 | config                | struct IERC721Drop.Configuration                              | 352  | 0      | 64    | src/ERC721Drop.sol:ERC721Drop |
 | salesConfig           | struct IERC721Drop.SalesConfiguration                         | 354  | 0      | 96    | src/ERC721Drop.sol:ERC721Drop |
 | presaleMintsByAddress | mapping(address => uint256)                                   | 357  | 0      | 32    | src/ERC721Drop.sol:ERC721Drop |
+| royaltyMintSchedule   | uint32                                                        | 358  | 0      | 4     | src/ERC721Drop.sol:ERC721Drop |
 
 =======================
 ➡ ERC721DropProxy

addresses/5.json

@@ -1,7 +1,11 @@
 {
-  "DROP_METADATA_RENDERER": "0x5956Fd16c4d8c4b4711F2551971aBB7c2F4aF677",
+  "ZORA_NFT_CREATOR_V1": "0xb4d319458E489825Cea8e25b5e43742BCdAFc6dd",
+  "ZORA_NFT_CREATOR_PROXY": "0xb9583D05Ba9ba8f7F14CCEe3Da10D2bc0A72f519",
+  "ZORA_ERC721_TRANSFER_HELPER": "0xd1adAF05575295710dE1145c3c9427c364A70a7f",
+  "ZORA_FEE_MANAGER": "0xCf5E957CA7b77EC16611992d79f4E179132ad98C",
   "EDITION_METADATA_RENDERER": "0x2f5C21EF9DdFf9A1FE76a1c55dd5112fcf2EfD39",
-  "ERC721DROP_IMPL": "0x9dbc5D5Abc25460195e34fF42916eF6D183Cfafd",
+  "DROP_METADATA_RENDERER": "0x5956Fd16c4d8c4b4711F2551971aBB7c2F4aF677",
+  "ERC721_DROP": "0x2093eFB737C07324D8b6c5807910EFF45045D987",
   "FACTORY_UPGRADE_GATE": "0x942C03C7afE5c8118BDB728Aa06d1b894B1cD9A8",
   "ZORA_NFT_CREATOR_PROXY": "0xb9583D05Ba9ba8f7F14CCEe3Da10D2bc0A72f519",
   "ZORA_NFT_CREATOR_V1_IMPL": "0x4328cbDAD668E81B475766520E1004e6688D2949"

foundry.toml

@@ -1,7 +1,7 @@
 [profile.default]
 solc_version = '0.8.17'
 optimizer = true
-optimizer_runs = 5000
+optimizer_runs = 3000
 via_ir = true
 out = 'dist/artifacts'
 test = 'test'

src/ERC721Drop.sol

@@ -23,6 +23,7 @@ import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/acce
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import {MerkleProofUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {MathUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
 
 import {IMetadataRenderer} from "./interfaces/IMetadataRenderer.sol";
 import {IOperatorFilterRegistry} from "./interfaces/IOperatorFilterRegistry.sol";
@@ -35,6 +36,8 @@ import {FundsReceiver} from "./utils/FundsReceiver.sol";
 import {Version} from "./utils/Version.sol";
 import {PublicMulticall} from "./utils/PublicMulticall.sol";
 import {ERC721DropStorageV1} from "./storage/ERC721DropStorageV1.sol";
+import {ERC721DropStorageV2} from "./storage/ERC721DropStorageV2.sol";
+
 
 /**
  * @notice ZORA NFT Base contract for Drops and Editions
@@ -55,8 +58,9 @@ contract ERC721Drop is
     PublicMulticall,
     OwnableSkeleton,
     FundsReceiver,
-    Version(12),
-    ERC721DropStorageV1
+    Version(13),
+    ERC721DropStorageV1,
+    ERC721DropStorageV2
 {
     /// @dev This is the max mint batch size for the optimized ERC721A mint contract
     uint256 internal immutable MAX_MINT_BATCH_SIZE = 8;
@@ -83,6 +87,8 @@ contract ERC721Drop is
     /// @notice Max royalty BPS
     uint16 constant MAX_ROYALTY_BPS = 50_00;
 
+    uint8 constant SUPPLY_ROYALTY_FOR_EVERY_MINT = 1;
+
     // /// @notice Empty string for blank comments
     // string constant EMPTY_STRING = "";
 
@@ -440,7 +446,6 @@ contract ERC721Drop is
         external
         payable
         nonReentrant
-        canMintTokens(quantity)
         onlyPublicSaleActive
         returns (uint256)
     {
@@ -455,14 +460,16 @@ contract ERC721Drop is
         external
         payable
         nonReentrant
-        canMintTokens(quantity)
         onlyPublicSaleActive
         returns (uint256)
     {
         return _handlePurchase(quantity, comment);
     }
 
     function _handlePurchase(uint256 quantity, string memory comment) internal returns (uint256) {
+        _mintSupplyRoyalty(quantity);
+        _requireCanMintQuantity(quantity);
+
         uint256 salePrice = salesConfig.publicSalePrice;
 
         if (msg.value != (salePrice + ZORA_MINT_FEE) * quantity) {
@@ -594,7 +601,6 @@ contract ERC721Drop is
         external
         payable
         nonReentrant
-        canMintTokens(quantity)
         onlyPresaleActive
         returns (uint256)
     {
@@ -617,7 +623,6 @@ contract ERC721Drop is
         external
         payable
         nonReentrant
-        canMintTokens(quantity)
         onlyPresaleActive
         returns (uint256)
     {
@@ -631,6 +636,9 @@ contract ERC721Drop is
         bytes32[] calldata merkleProof,
         string memory comment
     ) internal returns (uint256) {
+        _mintSupplyRoyalty(quantity);
+        _requireCanMintQuantity(quantity);
+
         if (
             !MerkleProofUpgradeable.verify(
                 merkleProof,
@@ -1267,6 +1275,37 @@ contract ERC721Drop is
         emit MintFeePayout(zoraFee, ZORA_MINT_FEE_RECIPIENT, success);
     }
 
+    function _requireCanMintQuantity(uint256 quantity) internal view {
+        if (quantity + _totalMinted() > config.editionSize) {
+            revert Mint_SoldOut();
+        }
+    }
+
+    function _mintSupplyRoyalty(uint256 mintQuantity) internal {
+        uint32 royaltySchedule = royaltyMintSchedule;
+        if (royaltySchedule == 0) {
+            return;
+        }
+
+        address royaltyRecipient = config.fundsRecipient;            
+        if (royaltyRecipient == address(0)) {
+            return;
+        }
+
+        uint256 totalRoyaltyMints = (mintQuantity + (_totalMinted() % royaltySchedule)) / (royaltySchedule - 1);
+        totalRoyaltyMints = MathUpgradeable.min(totalRoyaltyMints, config.editionSize - (mintQuantity + _totalMinted()));
+        if (totalRoyaltyMints > 0) {
+            _mintNFTs(royaltyRecipient, totalRoyaltyMints);
+        }
+    }
+
+    function updateRoyaltyMintSchedule(uint32 newSchedule) external onlyAdmin {
+        if (newSchedule == SUPPLY_ROYALTY_FOR_EVERY_MINT) {
+            revert InvalidMintSchedule();
+        }
+        royaltyMintSchedule = newSchedule;
+    }
+
     /// @notice ERC165 supports interface
     /// @param interfaceId interface id to check if supported
     function supportsInterface(bytes4 interfaceId)

src/interfaces/IERC721Drop.sol

@@ -70,6 +70,8 @@ interface IERC721Drop {
     error Admin_InvalidUpgradeAddress(address proposedAddress);
     /// @notice Unable to finalize an edition not marked as open (size set to uint64_max_value)
     error Admin_UnableToFinalizeNotOpenEdition();
+    /// @notice Cannot reserve every mint for admin
+    error InvalidMintSchedule();
 
     /// @notice Event emitted for mint fee payout
     /// @param mintFeeAmount amount of the mint fee

src/storage/ERC721DropStorageV2.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+contract ERC721DropStorageV2 {
+    uint32 public royaltyMintSchedule;
+}

test/ERC721Drop.t.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.10;
 
 import {Test} from "forge-std/Test.sol";
 import {IERC721AUpgradeable} from "erc721a-upgradeable/IERC721AUpgradeable.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
 import {ERC721Drop} from "../src/ERC721Drop.sol";
 import {DummyMetadataRenderer} from "./utils/DummyMetadataRenderer.sol";
@@ -977,6 +978,144 @@ contract ERC721DropTest is Test {
         assertEq(dummyRenderer.someState(), "");
     }
 
+    function test_SupplyRoyaltyMintScheduleCannotBeOne() public setupZoraNFTBase(100) {
+        vm.startPrank(DEFAULT_OWNER_ADDRESS);
+        vm.expectRevert(IERC721Drop.InvalidMintSchedule.selector);
+        zoraNFTBase.updateRoyaltyMintSchedule(1);
+    }
+
+    function test_SupplyRoyaltyPurchase(uint32 royaltyMintSchedule, uint32 editionSize, uint256 mintQuantity) public setupZoraNFTBase(editionSize) {
+        vm.assume(royaltyMintSchedule > 1 && royaltyMintSchedule <= editionSize && editionSize <= 100000 && mintQuantity > 0 && mintQuantity <= editionSize);
+        uint256 totalRoyaltyMintsForSale = editionSize / royaltyMintSchedule;
+        vm.assume(mintQuantity <= editionSize - totalRoyaltyMintsForSale);
+
+        vm.startPrank(DEFAULT_OWNER_ADDRESS);
+
+        zoraNFTBase.updateRoyaltyMintSchedule(royaltyMintSchedule);
+
+        zoraNFTBase.setSaleConfiguration({
+            publicSaleStart: 0,
+            publicSaleEnd: type(uint64).max,
+            presaleStart: 0,
+            presaleEnd: 0,
+            publicSalePrice: 0.1 ether,
+            maxSalePurchasePerAddress: editionSize,
+            presaleMerkleRoot: bytes32(0)
+        });
+        vm.stopPrank();
+
+        uint256 totalRoyaltyMintsForPurchase = mintQuantity / (royaltyMintSchedule - 1);
+        totalRoyaltyMintsForPurchase = Math.min(totalRoyaltyMintsForPurchase, editionSize - mintQuantity);
+        (, uint256 zoraFee) = zoraNFTBase.zoraFeeForAmount(mintQuantity);
+
+        uint256 paymentAmount = 0.1 ether * mintQuantity + zoraFee;
+        vm.deal(address(456), paymentAmount);
+
+        vm.startPrank(address(456));
+        zoraNFTBase.purchase{value: paymentAmount}(mintQuantity);
+
+        assertEq(zoraNFTBase.balanceOf(address(456)), mintQuantity);
+        assertEq(zoraNFTBase.balanceOf(DEFAULT_FUNDS_RECIPIENT_ADDRESS), totalRoyaltyMintsForPurchase);
+
+        vm.stopPrank();
+    }
+
+    function test_SupplyRoyaltyCleanNumbers() public setupZoraNFTBase(100) {
+        vm.startPrank(DEFAULT_OWNER_ADDRESS);
+
+        zoraNFTBase.updateRoyaltyMintSchedule(5);
+
+        zoraNFTBase.setSaleConfiguration({
+            publicSaleStart: 0,
+            publicSaleEnd: type(uint64).max,
+            presaleStart: 0,
+            presaleEnd: 0,
+            publicSalePrice: 0.1 ether,
+            maxSalePurchasePerAddress: 100,
+            presaleMerkleRoot: bytes32(0)
+        });
+        vm.stopPrank();
+
+        (, uint256 zoraFee) = zoraNFTBase.zoraFeeForAmount(80);
+        uint256 paymentAmount = 0.1 ether * 80 + zoraFee;
+        vm.deal(address(456), paymentAmount);
+
+        vm.startPrank(address(456));
+        zoraNFTBase.purchase{value: paymentAmount}(80);
+
+        assertEq(zoraNFTBase.balanceOf(address(456)), 80);
+        assertEq(zoraNFTBase.balanceOf(DEFAULT_FUNDS_RECIPIENT_ADDRESS), 20);
+
+        vm.stopPrank();
+    }
+
+    function test_SupplyRoyaltyEdgeCaseNumbers() public setupZoraNFTBase(137) {
+        vm.startPrank(DEFAULT_OWNER_ADDRESS);
+
+        zoraNFTBase.updateRoyaltyMintSchedule(3);
+
+        zoraNFTBase.setSaleConfiguration({
+            publicSaleStart: 0,
+            publicSaleEnd: type(uint64).max,
+            presaleStart: 0,
+            presaleEnd: 0,
+            publicSalePrice: 0.1 ether,
+            maxSalePurchasePerAddress: 92,
+            presaleMerkleRoot: bytes32(0)
+        });
+        vm.stopPrank();
+
+        (, uint256 zoraFee) = zoraNFTBase.zoraFeeForAmount(92);
+        uint256 paymentAmount = 0.1 ether * 92 + zoraFee;
+        vm.deal(address(456), paymentAmount);
+
+        vm.startPrank(address(456));
+        zoraNFTBase.purchase{value: paymentAmount}(92);
+
+        assertEq(zoraNFTBase.balanceOf(address(456)), 92);
+        assertEq(zoraNFTBase.balanceOf(DEFAULT_FUNDS_RECIPIENT_ADDRESS), 45);
+
+        vm.stopPrank();
+    }
+
+    function test_SupplyRoyaltyEdgeCaseNumbersOpenEdition() public setupZoraNFTBase(type(uint64).max) {
+        vm.startPrank(DEFAULT_OWNER_ADDRESS);
+
+        zoraNFTBase.updateRoyaltyMintSchedule(3);
+
+        zoraNFTBase.setSaleConfiguration({
+            publicSaleStart: 0,
+            publicSaleEnd: type(uint64).max,
+            presaleStart: 0,
+            presaleEnd: 0,
+            publicSalePrice: 0.1 ether,
+            maxSalePurchasePerAddress: 93,
+            presaleMerkleRoot: bytes32(0)
+        });
+        vm.stopPrank();
+
+        (, uint256 zoraFee) = zoraNFTBase.zoraFeeForAmount(92);
+        uint256 paymentAmount = 0.1 ether * 92 + zoraFee;
+        vm.deal(address(456), paymentAmount);
+
+        vm.startPrank(address(456));
+        zoraNFTBase.purchase{value: paymentAmount}(92);
+
+        assertEq(zoraNFTBase.balanceOf(address(456)), 92);
+        assertEq(zoraNFTBase.balanceOf(DEFAULT_FUNDS_RECIPIENT_ADDRESS), 46);
+
+        (, zoraFee) = zoraNFTBase.zoraFeeForAmount(1);
+        paymentAmount = 0.1 ether + zoraFee;
+        vm.deal(address(456), paymentAmount);
+
+        zoraNFTBase.purchase{value: paymentAmount}(1);
+
+        assertEq(zoraNFTBase.balanceOf(address(456)), 93);
+        assertEq(zoraNFTBase.balanceOf(DEFAULT_FUNDS_RECIPIENT_ADDRESS), 46);
+
+        vm.stopPrank();
+    }
+
     function test_EIP165() public view {
         require(zoraNFTBase.supportsInterface(0x01ffc9a7), "supports 165");
         require(zoraNFTBase.supportsInterface(0x80ac58cd), "supports 721");