@artblocks/contracts 1.2.0 → 1.2.1

package/contracts/interfaces/v0.8.x/integration-refs/OpenSea/SeaDropErrorsAndEvents.sol

@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: MIT
+// @dev file is sourced from OpenSea's repository: https://github.com/ProjectOpenSea/seadrop/blob/main/src/lib/SeaDropErrorsAndEvents.sol
+// @dev modified to not lock to specific version, as well as updated imports for this repository
+pragma solidity ^0.8.17;
+
+import {PublicDrop, TokenGatedDropStage, SignedMintValidationParams} from "./SeaDropStructs.sol";
+
+interface SeaDropErrorsAndEvents {
+    /**
+     * @dev Revert with an error if the drop stage is not active.
+     */
+    error NotActive(
+        uint256 currentTimestamp,
+        uint256 startTimestamp,
+        uint256 endTimestamp
+    );
+
+    /**
+     * @dev Revert with an error if the mint quantity is zero.
+     */
+    error MintQuantityCannotBeZero();
+
+    /**
+     * @dev Revert with an error if the mint quantity exceeds the max allowed
+     *      to be minted per wallet.
+     */
+    error MintQuantityExceedsMaxMintedPerWallet(uint256 total, uint256 allowed);
+
+    /**
+     * @dev Revert with an error if the mint quantity exceeds the max token
+     *      supply.
+     */
+    error MintQuantityExceedsMaxSupply(uint256 total, uint256 maxSupply);
+
+    /**
+     * @dev Revert with an error if the mint quantity exceeds the max token
+     *      supply for the stage.
+     *      Note: The `maxTokenSupplyForStage` for public mint is
+     *      always `type(uint).max`.
+     */
+    error MintQuantityExceedsMaxTokenSupplyForStage(
+        uint256 total,
+        uint256 maxTokenSupplyForStage
+    );
+
+    /**
+     * @dev Revert if the fee recipient is the zero address.
+     */
+    error FeeRecipientCannotBeZeroAddress();
+
+    /**
+     * @dev Revert if the fee recipient is not already included.
+     */
+    error FeeRecipientNotPresent();
+
+    /**
+     * @dev Revert if the fee basis points is greater than 10_000.
+     */
+    error InvalidFeeBps(uint256 feeBps);
+
+    /**
+     * @dev Revert if the fee recipient is already included.
+     */
+    error DuplicateFeeRecipient();
+
+    /**
+     * @dev Revert if the fee recipient is restricted and not allowed.
+     */
+    error FeeRecipientNotAllowed();
+
+    /**
+     * @dev Revert if the creator payout address is the zero address.
+     */
+    error CreatorPayoutAddressCannotBeZeroAddress();
+
+    /**
+     * @dev Revert with an error if the received payment is incorrect.
+     */
+    error IncorrectPayment(uint256 got, uint256 want);
+
+    /**
+     * @dev Revert with an error if the allow list proof is invalid.
+     */
+    error InvalidProof();
+
+    /**
+     * @dev Revert if a supplied signer address is the zero address.
+     */
+    error SignerCannotBeZeroAddress();
+
+    /**
+     * @dev Revert with an error if signer's signature is invalid.
+     */
+    error InvalidSignature(address recoveredSigner);
+
+    /**
+     * @dev Revert with an error if a signer is not included in
+     *      the enumeration when removing.
+     */
+    error SignerNotPresent();
+
+    /**
+     * @dev Revert with an error if a payer is not included in
+     *      the enumeration when removing.
+     */
+    error PayerNotPresent();
+
+    /**
+     * @dev Revert with an error if a payer is already included in mapping
+     *      when adding.
+     *      Note: only applies when adding a single payer, as duplicates in
+     *      enumeration can be removed with updatePayer.
+     */
+    error DuplicatePayer();
+
+    /**
+     * @dev Revert with an error if the payer is not allowed. The minter must
+     *      pay for their own mint.
+     */
+    error PayerNotAllowed();
+
+    /**
+     * @dev Revert if a supplied payer address is the zero address.
+     */
+    error PayerCannotBeZeroAddress();
+
+    /**
+     * @dev Revert with an error if the sender does not
+     *      match the INonFungibleSeaDropToken interface.
+     */
+    error OnlyINonFungibleSeaDropToken(address sender);
+
+    /**
+     * @dev Revert with an error if the sender of a token gated supplied
+     *      drop stage redeem is not the owner of the token.
+     */
+    error TokenGatedNotTokenOwner(
+        address nftContract,
+        address allowedNftToken,
+        uint256 allowedNftTokenId
+    );
+
+    /**
+     * @dev Revert with an error if the token id has already been used to
+     *      redeem a token gated drop stage.
+     */
+    error TokenGatedTokenIdAlreadyRedeemed(
+        address nftContract,
+        address allowedNftToken,
+        uint256 allowedNftTokenId
+    );
+
+    /**
+     * @dev Revert with an error if an empty TokenGatedDropStage is provided
+     *      for an already-empty TokenGatedDropStage.
+     */
+    error TokenGatedDropStageNotPresent();
+
+    /**
+     * @dev Revert with an error if an allowedNftToken is set to
+     *      the zero address.
+     */
+    error TokenGatedDropAllowedNftTokenCannotBeZeroAddress();
+
+    /**
+     * @dev Revert with an error if an allowedNftToken is set to
+     *      the drop token itself.
+     */
+    error TokenGatedDropAllowedNftTokenCannotBeDropToken();
+
+    /**
+     * @dev Revert with an error if supplied signed mint price is less than
+     *      the minimum specified.
+     */
+    error InvalidSignedMintPrice(uint256 got, uint256 minimum);
+
+    /**
+     * @dev Revert with an error if supplied signed maxTotalMintableByWallet
+     *      is greater than the maximum specified.
+     */
+    error InvalidSignedMaxTotalMintableByWallet(uint256 got, uint256 maximum);
+
+    /**
+     * @dev Revert with an error if supplied signed start time is less than
+     *      the minimum specified.
+     */
+    error InvalidSignedStartTime(uint256 got, uint256 minimum);
+
+    /**
+     * @dev Revert with an error if supplied signed end time is greater than
+     *      the maximum specified.
+     */
+    error InvalidSignedEndTime(uint256 got, uint256 maximum);
+
+    /**
+     * @dev Revert with an error if supplied signed maxTokenSupplyForStage
+     *      is greater than the maximum specified.
+     */
+    error InvalidSignedMaxTokenSupplyForStage(uint256 got, uint256 maximum);
+
+    /**
+     * @dev Revert with an error if supplied signed feeBps is greater than
+     *      the maximum specified, or less than the minimum.
+     */
+    error InvalidSignedFeeBps(uint256 got, uint256 minimumOrMaximum);
+
+    /**
+     * @dev Revert with an error if signed mint did not specify to restrict
+     *      fee recipients.
+     */
+    error SignedMintsMustRestrictFeeRecipients();
+
+    /**
+     * @dev Revert with an error if a signature for a signed mint has already
+     *      been used.
+     */
+    error SignatureAlreadyUsed();
+
+    /**
+     * @dev An event with details of a SeaDrop mint, for analytical purposes.
+     *
+     * @param nftContract    The nft contract.
+     * @param minter         The mint recipient.
+     * @param feeRecipient   The fee recipient.
+     * @param payer          The address who payed for the tx.
+     * @param quantityMinted The number of tokens minted.
+     * @param unitMintPrice  The amount paid for each token.
+     * @param feeBps         The fee out of 10_000 basis points collected.
+     * @param dropStageIndex The drop stage index. Items minted
+     *                       through mintPublic() have
+     *                       dropStageIndex of 0.
+     */
+    event SeaDropMint(
+        address indexed nftContract,
+        address indexed minter,
+        address indexed feeRecipient,
+        address payer,
+        uint256 quantityMinted,
+        uint256 unitMintPrice,
+        uint256 feeBps,
+        uint256 dropStageIndex
+    );
+
+    /**
+     * @dev An event with updated public drop data for an nft contract.
+     */
+    event PublicDropUpdated(address indexed nftContract, PublicDrop publicDrop);
+
+    /**
+     * @dev An event with updated token gated drop stage data
+     *      for an nft contract.
+     */
+    event TokenGatedDropStageUpdated(
+        address indexed nftContract,
+        address indexed allowedNftToken,
+        TokenGatedDropStage dropStage
+    );
+
+    /**
+     * @dev An event with updated allow list data for an nft contract.
+     *
+     * @param nftContract        The nft contract.
+     * @param previousMerkleRoot The previous allow list merkle root.
+     * @param newMerkleRoot      The new allow list merkle root.
+     * @param publicKeyURI       If the allow list is encrypted, the public key
+     *                           URIs that can decrypt the list.
+     *                           Empty if unencrypted.
+     * @param allowListURI       The URI for the allow list.
+     */
+    event AllowListUpdated(
+        address indexed nftContract,
+        bytes32 indexed previousMerkleRoot,
+        bytes32 indexed newMerkleRoot,
+        string[] publicKeyURI,
+        string allowListURI
+    );
+
+    /**
+     * @dev An event with updated drop URI for an nft contract.
+     */
+    event DropURIUpdated(address indexed nftContract, string newDropURI);
+
+    /**
+     * @dev An event with the updated creator payout address for an nft
+     *      contract.
+     */
+    event CreatorPayoutAddressUpdated(
+        address indexed nftContract,
+        address indexed newPayoutAddress
+    );
+
+    /**
+     * @dev An event with the updated allowed fee recipient for an nft
+     *      contract.
+     */
+    event AllowedFeeRecipientUpdated(
+        address indexed nftContract,
+        address indexed feeRecipient,
+        bool indexed allowed
+    );
+
+    /**
+     * @dev An event with the updated validation parameters for server-side
+     *      signers.
+     */
+    event SignedMintValidationParamsUpdated(
+        address indexed nftContract,
+        address indexed signer,
+        SignedMintValidationParams signedMintValidationParams
+    );
+
+    /**
+     * @dev An event with the updated payer for an nft contract.
+     */
+    event PayerUpdated(
+        address indexed nftContract,
+        address indexed payer,
+        bool indexed allowed
+    );
+}

package/contracts/interfaces/v0.8.x/integration-refs/OpenSea/SeaDropStructs.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: MIT
+// @dev file is sourced from OpenSea's repository: https://github.com/ProjectOpenSea/seadrop/blob/main/src/lib/SeaDropStructs.sol
+// @dev modified to not lock to specific version
+pragma solidity ^0.8.17;
+
+/**
+ * @notice A struct defining public drop data.
+ *         Designed to fit efficiently in one storage slot.
+ *
+ * @param mintPrice                The mint price per token. (Up to 1.2m
+ *                                 of native token, e.g. ETH, MATIC)
+ * @param startTime                The start time, ensure this is not zero.
+ * @param endTIme                  The end time, ensure this is not zero.
+ * @param maxTotalMintableByWallet Maximum total number of mints a user is
+ *                                 allowed. (The limit for this field is
+ *                                 2^16 - 1)
+ * @param feeBps                   Fee out of 10_000 basis points to be
+ *                                 collected.
+ * @param restrictFeeRecipients    If false, allow any fee recipient;
+ *                                 if true, check fee recipient is allowed.
+ */
+struct PublicDrop {
+    uint80 mintPrice; // 80/256 bits
+    uint48 startTime; // 128/256 bits
+    uint48 endTime; // 176/256 bits
+    uint16 maxTotalMintableByWallet; // 224/256 bits
+    uint16 feeBps; // 240/256 bits
+    bool restrictFeeRecipients; // 248/256 bits
+}
+
+/**
+ * @notice A struct defining token gated drop stage data.
+ *         Designed to fit efficiently in one storage slot.
+ *
+ * @param mintPrice                The mint price per token. (Up to 1.2m
+ *                                 of native token, e.g.: ETH, MATIC)
+ * @param maxTotalMintableByWallet Maximum total number of mints a user is
+ *                                 allowed. (The limit for this field is
+ *                                 2^16 - 1)
+ * @param startTime                The start time, ensure this is not zero.
+ * @param endTime                  The end time, ensure this is not zero.
+ * @param dropStageIndex           The drop stage index to emit with the event
+ *                                 for analytical purposes. This should be
+ *                                 non-zero since the public mint emits
+ *                                 with index zero.
+ * @param maxTokenSupplyForStage   The limit of token supply this stage can
+ *                                 mint within. (The limit for this field is
+ *                                 2^16 - 1)
+ * @param feeBps                   Fee out of 10_000 basis points to be
+ *                                 collected.
+ * @param restrictFeeRecipients    If false, allow any fee recipient;
+ *                                 if true, check fee recipient is allowed.
+ */
+struct TokenGatedDropStage {
+    uint80 mintPrice; // 80/256 bits
+    uint16 maxTotalMintableByWallet; // 96/256 bits
+    uint48 startTime; // 144/256 bits
+    uint48 endTime; // 192/256 bits
+    uint8 dropStageIndex; // non-zero. 200/256 bits
+    uint32 maxTokenSupplyForStage; // 232/256 bits
+    uint16 feeBps; // 248/256 bits
+    bool restrictFeeRecipients; // 256/256 bits
+}
+
+/**
+ * @notice A struct defining mint params for an allow list.
+ *         An allow list leaf will be composed of `msg.sender` and
+ *         the following params.
+ *
+ *         Note: Since feeBps is encoded in the leaf, backend should ensure
+ *         that feeBps is acceptable before generating a proof.
+ *
+ * @param mintPrice                The mint price per token.
+ * @param maxTotalMintableByWallet Maximum total number of mints a user is
+ *                                 allowed.
+ * @param startTime                The start time, ensure this is not zero.
+ * @param endTime                  The end time, ensure this is not zero.
+ * @param dropStageIndex           The drop stage index to emit with the event
+ *                                 for analytical purposes. This should be
+ *                                 non-zero since the public mint emits with
+ *                                 index zero.
+ * @param maxTokenSupplyForStage   The limit of token supply this stage can
+ *                                 mint within.
+ * @param feeBps                   Fee out of 10_000 basis points to be
+ *                                 collected.
+ * @param restrictFeeRecipients    If false, allow any fee recipient;
+ *                                 if true, check fee recipient is allowed.
+ */
+struct MintParams {
+    uint256 mintPrice;
+    uint256 maxTotalMintableByWallet;
+    uint256 startTime;
+    uint256 endTime;
+    uint256 dropStageIndex; // non-zero
+    uint256 maxTokenSupplyForStage;
+    uint256 feeBps;
+    bool restrictFeeRecipients;
+}
+
+/**
+ * @notice A struct defining token gated mint params.
+ *
+ * @param allowedNftToken    The allowed nft token contract address.
+ * @param allowedNftTokenIds The token ids to redeem.
+ */
+struct TokenGatedMintParams {
+    address allowedNftToken;
+    uint256[] allowedNftTokenIds;
+}
+
+/**
+ * @notice A struct defining allow list data (for minting an allow list).
+ *
+ * @param merkleRoot    The merkle root for the allow list.
+ * @param publicKeyURIs If the allowListURI is encrypted, a list of URIs
+ *                      pointing to the public keys. Empty if unencrypted.
+ * @param allowListURI  The URI for the allow list.
+ */
+struct AllowListData {
+    bytes32 merkleRoot;
+    string[] publicKeyURIs;
+    string allowListURI;
+}
+
+/**
+ * @notice A struct defining minimum and maximum parameters to validate for
+ *         signed mints, to minimize negative effects of a compromised signer.
+ *
+ * @param minMintPrice                The minimum mint price allowed.
+ * @param maxMaxTotalMintableByWallet The maximum total number of mints allowed
+ *                                    by a wallet.
+ * @param minStartTime                The minimum start time allowed.
+ * @param maxEndTime                  The maximum end time allowed.
+ * @param maxMaxTokenSupplyForStage   The maximum token supply allowed.
+ * @param minFeeBps                   The minimum fee allowed.
+ * @param maxFeeBps                   The maximum fee allowed.
+ */
+struct SignedMintValidationParams {
+    uint80 minMintPrice; // 80/256 bits
+    uint24 maxMaxTotalMintableByWallet; // 104/256 bits
+    uint40 minStartTime; // 144/256 bits
+    uint40 maxEndTime; // 184/256 bits
+    uint40 maxMaxTokenSupplyForStage; // 224/256 bits
+    uint16 minFeeBps; // 240/256 bits
+    uint16 maxFeeBps; // 256/256 bits
+}

package/contracts/libs/v0.8.x/Bytes32Strings.sol

@@ -63,4 +63,24 @@ library Bytes32Strings {
         }
         return _occurrences == targetQty;
     }
+
+    /**
+     * @notice Converts string to bytes32.
+     * https://ethereum.stackexchange.com/a/9152
+     * @param source string to be converted.
+     * @return result bytes32 representation of string.
+     * @dev If string is longer than 32 bytes, it truncates to the right.
+     */
+    function stringToBytes32(
+        string memory source
+    ) internal pure returns (bytes32 result) {
+        bytes memory tempEmptyStringTest = bytes(source);
+        if (tempEmptyStringTest.length == 0) {
+            return 0x0;
+        }
+
+        assembly ("memory-safe") {
+            result := mload(add(source, 32))
+        }
+    }
 }

package/contracts/libs/v0.8.x/DependencyRegistryStorageLib.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.19;
 
 import "../../interfaces/v0.8.x/IAdminACLV0.sol";
+import "../../interfaces/v0.8.x/ICoreRegistryV1.sol";
 import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
 
 /**
@@ -66,14 +67,21 @@ library DependencyRegistryStorageLib {
         mapping(bytes32 dependencyNameAndVersion => Dependency dependency) dependencyRecords;
         // mapping from licenseTypes to License, which stores the properties of each license
         mapping(bytes32 licenseType => License license) allLicenses;
-        // Set of addresses for the core contracts that are supported by the DependencyRegistry.
-        // Each address represents a unique core contract in the Art Blocks ecosystem.
-        EnumerableSet.AddressSet supportedCoreContracts;
+        // @dev This set is vestigial and no longer used. It has been replaced by CoreRegistry functionality.
+        // Cannot be removed due to storage layout requirements in upgradeable contracts.
+        // See https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable#modifying-your-contracts
+        EnumerableSet.AddressSet DEPRECATED_supportedCoreContracts;
         // Mapping that allows for the overriding of project dependencies.
         // The first key is the address of the core contract, the second key is the project ID,
         // and the value is the bytes32 representation of the dependency name and version (i.e. name@version).
         // This allows for specific projects to use different versions of dependencies than what's stored on the core contract.
         mapping(address coreContractAddress => mapping(uint256 projectId => bytes32 dependencyNameAndVersion) projectToDependencyNameAndVersionMapping) projectDependencyOverrides;
+        // address of the CoreRegistry contract
+        ICoreRegistryV1 coreRegistryContract;
+        // enumerable set of core contract addresses supported by the DependencyRegistry, in addition to the set of core contracts
+        // that are supported by the CoreRegistry contract
+        // @dev possible there is overlap between the two sets, but not intentionally configured by admin.
+        EnumerableSet.AddressSet supportedCoreContractsOverride;
     }
 
     /**