@bananapus/721-hook-v6 0.0.1

package/src/interfaces/IJB721TiersHookStore.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJB721TokenUriResolver} from "./IJB721TokenUriResolver.sol";
+import {JB721Tier} from "../structs/JB721Tier.sol";
+import {JB721TierConfig} from "../structs/JB721TierConfig.sol";
+import {JB721TiersHookFlags} from "../structs/JB721TiersHookFlags.sol";
+
+interface IJB721TiersHookStore {
+    event CleanTiers(address indexed hook, address caller);
+
+    /// @notice Get the number of NFTs that the specified address owns from the specified 721 contract.
+    /// @param hook The 721 contract to get the balance within.
+    /// @param owner The address to check the balance of.
+    /// @return The number of NFTs the owner has from the 721 contract.
+    function balanceOf(address hook, address owner) external view returns (uint256);
+
+    /// @notice The combined cash out weight of the NFTs with the provided token IDs.
+    /// @param hook The 721 contract that the NFTs belong to.
+    /// @param tokenIds The token IDs of the NFTs to get the cash out weight of.
+    /// @return weight The cash out weight.
+    function cashOutWeightOf(address hook, uint256[] calldata tokenIds) external view returns (uint256 weight);
+
+    /// @notice The default reserve beneficiary for the provided 721 contract.
+    /// @param hook The 721 contract to get the default reserve beneficiary of.
+    /// @return The default reserve beneficiary address.
+    function defaultReserveBeneficiaryOf(address hook) external view returns (address);
+
+    /// @notice The encoded IPFS URI for the provided tier ID of the provided 721 contract.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param tierId The ID of the tier to get the encoded IPFS URI of.
+    /// @return The encoded IPFS URI.
+    function encodedIPFSUriOf(address hook, uint256 tierId) external view returns (bytes32);
+
+    /// @notice The encoded IPFS URI for the tier of the 721 with the provided token ID.
+    /// @param hook The 721 contract that the encoded IPFS URI belongs to.
+    /// @param tokenId The token ID of the 721 to get the encoded tier IPFS URI of.
+    /// @return The encoded IPFS URI.
+    function encodedTierIPFSUriOf(address hook, uint256 tokenId) external view returns (bytes32);
+
+    /// @notice Get the flags that dictate the behavior of the provided 721 contract.
+    /// @param hook The 721 contract to get the flags of.
+    /// @return The flags.
+    function flagsOf(address hook) external view returns (JB721TiersHookFlags memory);
+
+    /// @notice Check if the provided tier has been removed from the provided 721 contract.
+    /// @param hook The 721 contract the tier belongs to.
+    /// @param tierId The ID of the tier to check the removal status of.
+    /// @return Whether the tier has been removed.
+    function isTierRemoved(address hook, uint256 tierId) external view returns (bool);
+
+    /// @notice The largest tier ID currently used on the provided 721 contract.
+    /// @param hook The 721 contract to get the largest tier ID from.
+    /// @return The largest tier ID.
+    function maxTierIdOf(address hook) external view returns (uint256);
+
+    /// @notice The number of NFTs which have been burned from the provided tier ID.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param tierId The ID of the tier to get the burn count of.
+    /// @return The number of burned NFTs.
+    function numberOfBurnedFor(address hook, uint256 tierId) external view returns (uint256);
+
+    /// @notice The number of pending reserve NFTs for the provided tier ID.
+    /// @param hook The 721 contract to check for pending reserved NFTs.
+    /// @param tierId The ID of the tier to get the number of pending reserves for.
+    /// @return The number of pending reserved NFTs.
+    function numberOfPendingReservesFor(address hook, uint256 tierId) external view returns (uint256);
+
+    /// @notice The number of reserve NFTs which have been minted from the provided tier ID.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param tierId The ID of the tier to get the reserve mint count of.
+    /// @return The number of reserve NFTs minted.
+    function numberOfReservesMintedFor(address hook, uint256 tierId) external view returns (uint256);
+
+    /// @notice The reserve beneficiary for the provided tier ID on the provided 721 contract.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param tierId The ID of the tier to get the reserve beneficiary of.
+    /// @return The reserve beneficiary address.
+    function reserveBeneficiaryOf(address hook, uint256 tierId) external view returns (address);
+
+    /// @notice The number of NFTs the provided owner address owns from the provided tier.
+    /// @param hook The 721 contract to get the balance from.
+    /// @param owner The address to get the tier balance of.
+    /// @param tierId The ID of the tier to get the balance for.
+    /// @return The tier balance.
+    function tierBalanceOf(address hook, address owner, uint256 tierId) external view returns (uint256);
+
+    /// @notice The tier ID for the 721 with the provided token ID.
+    /// @param tokenId The token ID of the 721 to get the tier ID of.
+    /// @return The tier ID.
+    function tierIdOfToken(uint256 tokenId) external pure returns (uint256);
+
+    /// @notice Get the tier with the provided ID from the provided 721 contract.
+    /// @param hook The 721 contract to get the tier from.
+    /// @param id The ID of the tier to get.
+    /// @param includeResolvedUri If `true`, the resolved token URI will be included.
+    /// @return tier The tier.
+    function tierOf(address hook, uint256 id, bool includeResolvedUri) external view returns (JB721Tier memory tier);
+
+    /// @notice Get the tier of the 721 with the provided token ID.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param tokenId The token ID of the 721 to get the tier of.
+    /// @param includeResolvedUri If `true`, the resolved token URI will be included.
+    /// @return tier The tier.
+    function tierOfTokenId(
+        address hook,
+        uint256 tokenId,
+        bool includeResolvedUri
+    )
+        external
+        view
+        returns (JB721Tier memory tier);
+
+    /// @notice Get an array of currently active 721 tiers for the provided 721 contract.
+    /// @param hook The 721 contract to get the tiers of.
+    /// @param categories An array of tier categories to get tiers from. Empty for all categories.
+    /// @param includeResolvedUri If `true`, the resolved token URIs will be included.
+    /// @param startingId The ID of the first tier to get. Send 0 to get all active tiers.
+    /// @param size The number of tiers to include.
+    /// @return tiers An array of active 721 tiers.
+    function tiersOf(
+        address hook,
+        uint256[] calldata categories,
+        bool includeResolvedUri,
+        uint256 startingId,
+        uint256 size
+    )
+        external
+        view
+        returns (JB721Tier[] memory tiers);
+
+    /// @notice The number of voting units an address has within the specified tier.
+    /// @param hook The 721 contract that the tier belongs to.
+    /// @param account The address to get the voting units of within the tier.
+    /// @param tierId The ID of the tier to get voting units within.
+    /// @return units The voting units.
+    function tierVotingUnitsOf(address hook, address account, uint256 tierId) external view returns (uint256 units);
+
+    /// @notice The custom token URI resolver for the provided 721 contract.
+    /// @param hook The 721 contract to get the custom token URI resolver of.
+    /// @return The token URI resolver.
+    function tokenUriResolverOf(address hook) external view returns (IJB721TokenUriResolver);
+
+    /// @notice The combined cash out weight for all NFTs from the provided 721 contract.
+    /// @param hook The 721 contract to get the total cash out weight of.
+    /// @return weight The total cash out weight.
+    function totalCashOutWeight(address hook) external view returns (uint256 weight);
+
+    /// @notice The total number of NFTs minted from the provided 721 contract.
+    /// @param hook The 721 contract to get a total supply of.
+    /// @return The total supply.
+    function totalSupplyOf(address hook) external view returns (uint256);
+
+    /// @notice The total number of voting units an address has for the provided 721 contract.
+    /// @param hook The 721 contract to get the voting units within.
+    /// @param account The address to get the voting unit total of.
+    /// @return units The total voting units.
+    function votingUnitsOf(address hook, address account) external view returns (uint256 units);
+
+    /// @notice Clean removed tiers from the tier sorting sequence.
+    /// @param hook The 721 contract to clean tiers for.
+    function cleanTiers(address hook) external;
+
+    /// @notice Record newly added tiers.
+    /// @param tiersToAdd The tiers to add.
+    /// @return tierIds The IDs of the tiers being added.
+    function recordAddTiers(JB721TierConfig[] calldata tiersToAdd) external returns (uint256[] memory tierIds);
+
+    /// @notice Record 721 burns.
+    /// @param tokenIds The token IDs of the NFTs to burn.
+    function recordBurn(uint256[] calldata tokenIds) external;
+
+    /// @notice Record newly set flags.
+    /// @param flags The flags to set.
+    function recordFlags(JB721TiersHookFlags calldata flags) external;
+
+    /// @notice Record 721 mints from the provided tiers.
+    /// @param amount The amount being spent on NFTs.
+    /// @param tierIds The IDs of the tiers to mint from.
+    /// @param isOwnerMint Whether this is a direct owner mint.
+    /// @return tokenIds The token IDs of the NFTs which were minted.
+    /// @return leftoverAmount The amount remaining after minting.
+    function recordMint(
+        uint256 amount,
+        uint16[] calldata tierIds,
+        bool isOwnerMint
+    )
+        external
+        returns (uint256[] memory tokenIds, uint256 leftoverAmount);
+
+    /// @notice Record reserve 721 minting for the provided tier ID.
+    /// @param tierId The ID of the tier to mint reserves from.
+    /// @param count The number of reserve NFTs to mint.
+    /// @return tokenIds The token IDs of the reserve NFTs which were minted.
+    function recordMintReservesFor(uint256 tierId, uint256 count) external returns (uint256[] memory tokenIds);
+
+    /// @notice Record tiers being removed.
+    /// @param tierIds The IDs of the tiers being removed.
+    function recordRemoveTierIds(uint256[] calldata tierIds) external;
+
+    /// @notice Record the setting of a discount for a tier.
+    /// @param tierId The ID of the tier to set the discount of.
+    /// @param discountPercent The new discount percent being applied.
+    function recordSetDiscountPercentOf(uint256 tierId, uint256 discountPercent) external;
+
+    /// @notice Record a new encoded IPFS URI for a tier.
+    /// @param tierId The ID of the tier to set the encoded IPFS URI of.
+    /// @param encodedIPFSUri The encoded IPFS URI to set for the tier.
+    function recordSetEncodedIPFSUriOf(uint256 tierId, bytes32 encodedIPFSUri) external;
+
+    /// @notice Record a newly set token URI resolver.
+    /// @param resolver The resolver to set.
+    function recordSetTokenUriResolver(IJB721TokenUriResolver resolver) external;
+
+    /// @notice Record an 721 transfer.
+    /// @param tierId The ID of the tier that the 721 being transferred belongs to.
+    /// @param from The address that the 721 is being transferred from.
+    /// @param to The address that the 721 is being transferred to.
+    function recordTransferForTier(uint256 tierId, address from, address to) external;
+}

package/src/interfaces/IJB721TokenUriResolver.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IJB721TokenUriResolver {
+    /// @notice Resolve the token URI for the given NFT.
+    /// @param nft The address of the NFT contract.
+    /// @param tokenId The token ID of the NFT to get the URI of.
+    /// @return tokenUri The token URI.
+    function tokenUriOf(address nft, uint256 tokenId) external view returns (string memory tokenUri);
+}

package/src/libraries/JB721Constants.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Global constants used across 721 hook contracts.
+library JB721Constants {
+    uint16 public constant DISCOUNT_DENOMINATOR = 200;
+}

package/src/libraries/JB721TiersRulesetMetadataResolver.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {JB721TiersRulesetMetadata} from "../structs/JB721TiersRulesetMetadata.sol";
+
+/// @title JB721TiersRulesetMetadataResolver
+/// @notice Utility library to parse and store ruleset metadata associated for the tiered 721 hook.
+/// @dev This library parses the `metadata` member of the `JBRulesetMetadata` struct.
+library JB721TiersRulesetMetadataResolver {
+    /// @notice Check whether transfers are paused based on the packed ruleset metadata.
+    /// @param data The packed metadata to check.
+    /// @return Whether transfers are paused (bit 0).
+    function transfersPaused(uint256 data) internal pure returns (bool) {
+        return (data & 1) == 1;
+    }
+
+    /// @notice Check whether minting pending reserves is paused based on the packed ruleset metadata.
+    /// @param data The packed metadata to check.
+    /// @return Whether minting pending reserves is paused (bit 1).
+    function mintPendingReservesPaused(uint256 data) internal pure returns (bool) {
+        return ((data >> 1) & 1) == 1;
+    }
+
+    /// @notice Pack the ruleset metadata for the 721 hook into a single `uint256`.
+    /// @param metadata The metadata to validate and pack.
+    /// @return packed A `uint256` containing the packed metadata for the 721 hook.
+    function pack721TiersRulesetMetadata(JB721TiersRulesetMetadata memory metadata)
+        internal
+        pure
+        returns (uint256 packed)
+    {
+        // pause transfers in bit 0.
+        if (metadata.pauseTransfers) packed |= 1;
+        // pause mint reserves in bit 1.
+        if (metadata.pauseMintPendingReserves) packed |= 1 << 1;
+    }
+
+    /// @notice Expand packed ruleset metadata for the 721 hook.
+    /// @param packedMetadata The packed metadata to expand.
+    /// @return metadata The metadata as a `JB721TiersRulesetMetadata` struct.
+    function expandMetadata(uint16 packedMetadata) internal pure returns (JB721TiersRulesetMetadata memory metadata) {
+        return JB721TiersRulesetMetadata(transfersPaused(packedMetadata), mintPendingReservesPaused(packedMetadata));
+    }
+}

package/src/libraries/JBBitmap.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {JBBitmapWord} from "../structs/JBBitmapWord.sol";
+
+/// @title JBBitmap
+/// @notice Utilities to manage a bool bitmap. Used for storing inactive tiers.
+library JBBitmap {
+    /// @notice Initialize a `JBBitmapWord` struct based on a mapping storage pointer and an index.
+    function readId(
+        mapping(uint256 => uint256) storage self,
+        uint256 index
+    )
+        internal
+        view
+        returns (JBBitmapWord memory)
+    {
+        uint256 depth = _retrieveDepth(index);
+
+        return JBBitmapWord({currentWord: self[depth], currentDepth: depth});
+    }
+
+    /// @notice Get the status of the specified bit within the `JBBitmapWord` struct.
+    /// @dev The `index` is the index that the bit would have if the bitmap were reshaped to a 1*n matrix.
+    /// @return The boolean value at the specified index, which indicates whether the corresponding tier has been
+    /// removed.
+    function isTierIdRemoved(JBBitmapWord memory self, uint256 index) internal pure returns (bool) {
+        return (self.currentWord >> (index % 256)) & 1 == 1;
+    }
+
+    /// @notice Get the status of the specified bit within the `JBBitmapWord` struct.
+    /// @dev The `index` is the index that the bit would have if the bitmap were reshaped to a 1*n matrix.
+    function isTierIdRemoved(mapping(uint256 => uint256) storage self, uint256 index) internal view returns (bool) {
+        uint256 depth = _retrieveDepth(index);
+        return isTierIdRemoved(JBBitmapWord({currentWord: self[depth], currentDepth: depth}), index);
+    }
+
+    /// @notice Set the bit at the given index to true, indicating that the corresponding tier has been removed.
+    /// @dev This is a one-way operation.
+    function removeTier(mapping(uint256 => uint256) storage self, uint256 index) internal {
+        uint256 depth = _retrieveDepth(index);
+        self[depth] |= uint256(1 << (index % 256));
+    }
+
+    /// @notice Check if the specified index is at a different depth than the current depth of the `JBBitmapWord`
+    /// struct.
+    /// @dev If the depth is different, the bitmap's current depth needs to be updated.
+    /// @return Whether the bitmap needs to be refreshed.
+    function refreshBitmapNeeded(JBBitmapWord memory self, uint256 index) internal pure returns (bool) {
+        return _retrieveDepth(index) != self.currentDepth;
+    }
+
+    /// @notice Return the line number (depth) of a given index within the bitmap matrix.
+    function _retrieveDepth(uint256 index) internal pure returns (uint256) {
+        return index >> 8; // div by 256
+    }
+}

package/src/libraries/JBIpfsDecoder.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+/// @title JBIpfsDecoder
+/// @notice Utilities to decode an IPFS hash.
+/// @dev This is fairly gas intensive due to multiple nested loops. Onchain IPFS hash decoding is not advised –
+/// storing them as a string *might* be more efficient for that use-case.
+library JBIpfsDecoder {
+    //*********************************************************************//
+    // ------------------- internal constant properties ------------------ //
+    //*********************************************************************//
+
+    /// @notice Just a kind reminder to our readers.
+    /// @dev Used in `base58ToString`
+    bytes internal constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+    /// @notice Decode an IPFS hash from a bytes32 and concatenate it with a base URI.
+    /// @param baseUri The base URI to prepend to the decoded IPFS hash.
+    /// @param hexString The encoded IPFS hash to decode.
+    /// @return The full URI with the base URI and decoded IPFS hash.
+    function decode(string memory baseUri, bytes32 hexString) internal pure returns (string memory) {
+        // All IPFS hashes start with a fixed sequence (0x12 and 0x20)
+        bytes memory completeHexString = abi.encodePacked(bytes2(0x1220), hexString);
+
+        // Convert the hex string to a hash
+        string memory ipfsHash = _toBase58(completeHexString);
+
+        // Concatenate with the base URI
+        return string(abi.encodePacked(baseUri, ipfsHash));
+    }
+
+    /// @notice Convert a hex string to base58
+    /// @notice Written by Martin Ludfall - Licence: MIT
+    function _toBase58(bytes memory source) private pure returns (string memory) {
+        if (source.length == 0) return new string(0);
+
+        uint8[] memory digits = new uint8[](46); // hash size with the prefix
+
+        digits[0] = 0;
+
+        uint8 digitlength = 1;
+        uint256 sourceLength = source.length;
+
+        for (uint256 i; i < sourceLength; i++) {
+            uint256 carry = uint8(source[i]);
+
+            for (uint256 j; j < digitlength;) {
+                carry += uint256(digits[j]) << 8; // mul 256
+                digits[j] = uint8(carry % 58);
+                carry = carry / 58;
+
+                unchecked {
+                    ++j;
+                }
+            }
+
+            while (carry > 0) {
+                digits[digitlength] = uint8(carry % 58);
+                unchecked {
+                    ++digitlength;
+                }
+                carry = carry / 58;
+            }
+        }
+        return string(_toAlphabet(_reverse(_truncate(digits, digitlength))));
+    }
+
+    function _truncate(uint8[] memory array, uint8 length) private pure returns (uint8[] memory) {
+        uint8[] memory output = new uint8[](length);
+        for (uint256 i; i < length; i++) {
+            output[i] = array[i];
+        }
+        return output;
+    }
+
+    function _reverse(uint8[] memory input) private pure returns (uint8[] memory) {
+        uint256 inputLength = input.length;
+        uint8[] memory output = new uint8[](inputLength);
+        for (uint256 i; i < inputLength; i++) {
+            unchecked {
+                output[i] = input[input.length - 1 - i];
+            }
+        }
+        return output;
+    }
+
+    function _toAlphabet(uint8[] memory indices) private pure returns (bytes memory) {
+        uint256 indicesLength = indices.length;
+        bytes memory output = new bytes(indicesLength);
+        for (uint256 i; i < indicesLength; i++) {
+            output[i] = ALPHABET[indices[i]];
+        }
+        return output;
+    }
+}

package/src/structs/JB721InitTiersConfig.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBPrices} from "@bananapus/core-v6/src/interfaces/IJBPrices.sol";
+
+import {JB721TierConfig} from "./JB721TierConfig.sol";
+
+/// @notice Config to initialize a `JB721TiersHook` with tiers and price data.
+/// @dev The `tiers` must be sorted by price (from least to greatest).
+/// @custom:member tiers The tiers to initialize the hook with.
+/// @custom:member currency The currency that the tier prices are denoted in. See `JBPrices`.
+/// @custom:member decimals The number of decimals in the fixed point tier prices.
+/// @custom:member prices A contract that exposes price feeds that can be used to calculate prices in different
+/// currencies. To only accept payments in `currency`, set `prices` to the zero address. See `JBPrices`.
+struct JB721InitTiersConfig {
+    JB721TierConfig[] tiers;
+    uint32 currency;
+    uint8 decimals;
+    IJBPrices prices;
+}

package/src/structs/JB721Tier.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member id The tier's ID.
+/// @custom:member price The price to buy an NFT in this tier, in terms of the currency in its `JBInitTiersConfig`.
+/// @custom:member remainingSupply The remaining number of NFTs which can be minted from this tier.
+/// @custom:member initialSupply The total number of NFTs which can be minted from this tier.
+/// @custom:member votingUnits The number of votes that each NFT in this tier gets.
+/// @custom:member reserveFrequency The frequency at which an extra NFT is minted for the `reserveBeneficiary` from this
+/// tier. With a `reserveFrequency` of 5, an extra NFT will be minted for the `reserveBeneficiary` for every 5 NFTs
+/// purchased.
+/// @custom:member reserveBeneficiary The address which receives any reserve NFTs from this tier.
+/// @custom:member encodedIPFSUri The IPFS URI to use for each NFT in this tier.
+/// @custom:member category The category that NFTs in this tier belongs to. Used to group NFT tiers.
+/// @custom:member discountPercent The discount that should be applied to the tier.
+/// @custom:member allowOwnerMint A boolean indicating whether the contract's owner can mint NFTs from this tier
+/// on-demand.
+/// @custom:member cannotBeRemoved A boolean indicating whether attempts to remove this tier will revert.
+/// @custom:member cannotIncreaseDiscountPercent If the tier cannot have its discount increased.
+/// @custom:member transfersPausable A boolean indicating whether transfers for NFTs in tier can be paused.
+/// @custom:member resolvedUri A resolved token URI for NFTs in this tier. Only available if the NFT this tier belongs
+/// to has a resolver.
+struct JB721Tier {
+    uint32 id;
+    uint104 price;
+    uint32 remainingSupply;
+    uint32 initialSupply;
+    uint104 votingUnits;
+    uint16 reserveFrequency;
+    address reserveBeneficiary;
+    bytes32 encodedIPFSUri;
+    uint24 category;
+    uint8 discountPercent;
+    bool allowOwnerMint;
+    bool transfersPausable;
+    bool cannotBeRemoved;
+    bool cannotIncreaseDiscountPercent;
+    string resolvedUri;
+}

package/src/structs/JB721TierConfig.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Config for a single NFT tier within a `JB721TiersHook`.
+/// @custom:member price The price to buy an NFT in this tier, in terms of the currency in its `JBInitTiersConfig`.
+/// @custom:member initialSupply The total number of NFTs which can be minted from this tier.
+/// @custom:member votingUnits The number of votes that each NFT in this tier gets if `useVotingUnits` is true.
+/// @custom:member reserveFrequency The frequency at which an extra NFT is minted for the `reserveBeneficiary` from this
+/// tier. With a `reserveFrequency` of 5, an extra NFT will be minted for the `reserveBeneficiary` for every 5 NFTs
+/// purchased.
+/// @custom:member reserveBeneficiary The address which receives any reserve NFTs from this tier. Overrides the default
+/// reserve beneficiary if one is set.
+/// @custom:member encodedIPFSUri The IPFS URI to use for each NFT in this tier.
+/// @custom:member category The category that NFTs in this tier belongs to. Used to group NFT tiers.
+/// @custom:member discountPercent The discount that should be applied to the tier.
+/// @custom:member allowOwnerMint A boolean indicating whether the contract's owner can mint NFTs from this tier
+/// on-demand.
+/// @custom:member useReserveBeneficiaryAsDefault A boolean indicating whether this tier's `reserveBeneficiary` should
+/// be stored as the default beneficiary for all tiers.
+/// @custom:member transfersPausable A boolean indicating whether transfers for NFTs in tier can be paused.
+/// @custom:member useVotingUnits A boolean indicating whether the `votingUnits` should be used to calculate voting
+/// power. If `useVotingUnits` is false, voting power is based on the tier's price.
+/// @custom:member cannotBeRemoved If the tier cannot be removed once added.
+/// @custom:member cannotIncreaseDiscount If the tier cannot have its discount increased.
+struct JB721TierConfig {
+    uint104 price;
+    uint32 initialSupply;
+    uint32 votingUnits;
+    uint16 reserveFrequency;
+    address reserveBeneficiary;
+    bytes32 encodedIPFSUri;
+    uint24 category;
+    uint8 discountPercent;
+    bool allowOwnerMint;
+    bool useReserveBeneficiaryAsDefault;
+    bool transfersPausable;
+    bool useVotingUnits;
+    bool cannotBeRemoved;
+    bool cannotIncreaseDiscountPercent;
+}

package/src/structs/JB721TiersHookFlags.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member noNewTiersWithReserves A boolean indicating whether attempts to add new tiers with a non-zero
+/// `reserveFrequency` will revert.
+/// @custom:member noNewTiersWithVotes A boolean indicating whether attempts to add new tiers with non-zero
+/// `votingUnits` will revert.
+/// @custom:member noNewTiersWithOwnerMinting A boolean indicating whether attempts to add new tiers with
+/// `allowOwnerMint` set to true will revert.
+/// @custom:member preventOverspending A boolean indicating whether payments attempting to spend more than the price of
+/// the NFTs being minted will revert.
+struct JB721TiersHookFlags {
+    bool noNewTiersWithReserves;
+    bool noNewTiersWithVotes;
+    bool noNewTiersWithOwnerMinting;
+    bool preventOverspending;
+}

package/src/structs/JB721TiersMintReservesConfig.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member tierId The ID of the tier to mint from.
+/// @custom:member count The number of NFTs to mint from that tier.
+struct JB721TiersMintReservesConfig {
+    uint32 tierId;
+    uint16 count;
+}

package/src/structs/JB721TiersRulesetMetadata.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice `JB721TiersHook` options which are packed and stored in the corresponding `JBRulesetMetadata.metadata` on a
+/// per-ruleset basis.
+/// @custom:member pauseTransfers A boolean indicating whether NFT transfers are paused during this ruleset.
+/// @custom:member pauseMintPendingReserves A boolean indicating whether pending/outstanding NFT reserves can be minted
+/// during this ruleset.
+struct JB721TiersRulesetMetadata {
+    bool pauseTransfers;
+    bool pauseMintPendingReserves;
+}

package/src/structs/JB721TiersSetDiscountPercentConfig.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member tierId The ID of the tier to set the discount percent for.
+/// @custom:member discountPercent The discount percent to set for the tier.
+struct JB721TiersSetDiscountPercentConfig {
+    uint32 tierId;
+    uint16 discountPercent;
+}

package/src/structs/JBBitmapWord.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @dev A "word" is a 256-bit integer that stores the status of 256 bits (true/false values). Each row of the
+/// `JBBitmap` matrix is a "word".
+/// @custom:member The information stored at the index.
+/// @custom:member The index.
+struct JBBitmapWord {
+    uint256 currentWord;
+    uint256 currentDepth;
+}

package/src/structs/JBDeploy721TiersHookConfig.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JB721InitTiersConfig} from "./JB721InitTiersConfig.sol";
+import {JB721TiersHookFlags} from "./JB721TiersHookFlags.sol";
+import {IJB721TokenUriResolver} from "../interfaces/IJB721TokenUriResolver.sol";
+
+/// @custom:member name The NFT collection's name.
+/// @custom:member symbol The NFT collection's symbol.
+/// @custom:member baseUri The URI to use as a base for full NFT URIs.
+/// @custom:member tokenUriResolver The contract responsible for resolving the URI for each NFT.
+/// @custom:member contractUri The URI where this contract's metadata can be found.
+/// @custom:member tiersConfig The NFT tiers and pricing config to launch the hook with.
+/// @custom:member reserveBeneficiary The default reserved beneficiary for all tiers.
+/// @custom:member flags A set of boolean options to configure the hook with.
+struct JBDeploy721TiersHookConfig {
+    string name;
+    string symbol;
+    string baseUri;
+    IJB721TokenUriResolver tokenUriResolver;
+    string contractUri;
+    JB721InitTiersConfig tiersConfig;
+    address reserveBeneficiary;
+    JB721TiersHookFlags flags;
+}

package/src/structs/JBLaunchProjectConfig.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+
+import {JBPayDataHookRulesetConfig} from "./JBPayDataHookRulesetConfig.sol";
+
+/// @custom:member projectUri Metadata URI to associate with the project. This can be updated any time by the owner of
+/// the project.
+/// @custom:member rulesetConfigurations The ruleset configurations to queue.
+/// @custom:member terminalConfigurations The terminal configurations to add for the project.
+/// @custom:member memo A memo to pass along to the emitted event.
+struct JBLaunchProjectConfig {
+    string projectUri;
+    JBPayDataHookRulesetConfig[] rulesetConfigurations;
+    JBTerminalConfig[] terminalConfigurations;
+    string memo;
+}