@artblocks/contracts 1.1.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/interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc. to support the 0xSplits V2 integration
+// Sourced from:
+//  - https://github.com/0xSplits/splits-contracts-monorepo/blob/main/packages/splits-v2/src/libraries/SplitV2.sol
+//  - https://github.com/0xSplits/splits-contracts-monorepo/blob/main/packages/splits-v2/src/splitters/SplitFactoryV2.sol
+
+pragma solidity ^0.8.0;
+
+interface ISplitFactoryV2 {
+    /* -------------------------------------------------------------------------- */
+    /*                                   STRUCTS                                  */
+    /* -------------------------------------------------------------------------- */
+
+    /**
+     * @notice Split struct
+     * @dev This struct is used to store the split information.
+     * @dev There are no hard caps on the number of recipients/totalAllocation/allocation unit. Thus the chain and its
+     * gas limits will dictate these hard caps. Please double check if the split you are creating can be distributed on
+     * the chain.
+     * @param recipients The recipients of the split.
+     * @param allocations The allocations of the split.
+     * @param totalAllocation The total allocation of the split.
+     * @param distributionIncentive The incentive for distribution. Limits max incentive to 6.5%.
+     */
+    struct Split {
+        address[] recipients;
+        uint256[] allocations;
+        uint256 totalAllocation;
+        uint16 distributionIncentive;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /*                                 FUNCTIONS                                  */
+    /* -------------------------------------------------------------------------- */
+
+    /**
+     * @notice Create a new split with params and owner.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _creator Creator of created split.
+     * @param _salt Salt for create2.
+     * @return split Address of the created split.
+     */
+    function createSplitDeterministic(
+        Split calldata _splitParams,
+        address _owner,
+        address _creator,
+        bytes32 _salt
+    ) external returns (address split);
+
+    /**
+     * @notice Predict the address of a new split and check if it is deployed.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _salt Salt for create2.
+     */
+    function isDeployed(
+        Split calldata _splitParams,
+        address _owner,
+        bytes32 _salt
+    ) external view returns (address split, bool exists);
+}

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

@@ -21,10 +21,8 @@ library ABHelpers {
         uint256 tokenId
     ) internal pure returns (uint256) {
         // int division properly rounds down
-        // @dev unchecked because will never divide by zero
-        unchecked {
-            return tokenId / ONE_MILLION;
-        }
+        // @dev no way to disable division by zero check in solidity v0.8.24, so not unchecked
+        return tokenId / ONE_MILLION;
     }
 
     /**
@@ -39,6 +37,22 @@ library ABHelpers {
         return tokenId % ONE_MILLION;
     }
 
+    /**
+     * @notice Function to convert token id to token invocation.
+     * @dev token invocation is the token number plus one, because token #0 is
+     * invocation 1.
+     * @param tokenId The id of the token.
+     */
+    function tokenIdToTokenInvocation(
+        uint256 tokenId
+    ) internal pure returns (uint256) {
+        unchecked {
+            // mod returns remainder, which is the token number
+            // @dev no way to disable mod zero check in solidity, unchecked to optimize gas for addition
+            return (tokenId % ONE_MILLION) + 1;
+        }
+    }
+
     /**
      * @notice Function to convert project id and token number to token id.
      * @param projectId The id of the project.

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

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Library for using uint256 as a mapping to 256 bool values via a bit map.
+ * This is useful for storing a large number of bool values in a compact way.
+ * @dev This implementation is similar to OpenZeppelin's BitMaps library, but a
+ * single uint256 is used directly in memory instead of operating within a
+ * a mapping within a storage struct.
+ * This design limits the number of indices to 256, but is more gas efficient
+ * for use cases that fit within that limit. This is especially true for
+ * operations that require many reads/writes, since SLOAD/SSTORE can be managed
+ * outside of the library.
+ */
+library BitMaps256 {
+    /**
+     * @notice Checks if the bit at a specific index in the bit map is set.
+     * A bit is considered set if it is 1, and unset if it is 0.
+     * @param bitMap BitMap to check.
+     * @param index The index of the bit to check.
+     * @return Indicating if the bit at the specified index is set, false otherwise.
+     */
+    function get(uint256 bitMap, uint8 index) internal pure returns (bool) {
+        uint256 mask = 1 << index;
+        return bitMap & mask != 0;
+    }
+
+    /**
+     * @notice Sets the bit at a specific index in the bit map to 1.
+     * This function creates a new bit map where the bit at the specified index is set,
+     * leaving other bits unchanged.
+     * @param bitMap The original BitMap.
+     * @param index The index of the bit to set.
+     * @return newBitMap The new bit map after setting the bit at the specified index.
+     */
+    function set(
+        uint256 bitMap,
+        uint8 index
+    ) internal pure returns (uint256 newBitMap) {
+        uint256 mask = 1 << index;
+        return bitMap | mask;
+    }
+
+    /**
+     * @notice Unsets the bit at a specific index in the bit map, setting it to 0.
+     * This function creates a new bit map where the bit at the specified index is unset,
+     * leaving other bits unchanged.
+     * @param bitMap The original BitMap.
+     * @param index The index of the bit to unset.
+     * @return newBitMap The new bit map after unsetting the bit at the specified index.
+     */
+    function unset(
+        uint256 bitMap,
+        uint8 index
+    ) internal pure returns (uint256 newBitMap) {
+        uint256 mask = 1 << index;
+        return bitMap & ~mask;
+    }
+
+    /**
+     * @notice Finds the index of the first bit that is set in the bit map
+     * starting from a given index.
+     * Returns (255, false) if no set bits were found.
+     * @param bitMap BitMap to search
+     * @param startIndex Index to start searching from, inclusive
+     * @return minIndex Index of first set bit, or 255 if no bits were found
+     * @return foundSetBit True if a set bit was found, false otherwise
+     */
+    function minBitSet(
+        uint256 bitMap,
+        uint8 startIndex
+    ) internal pure returns (uint256 minIndex, bool foundSetBit) {
+        // check if there's any set bit at or above startIndex
+        if ((bitMap >> startIndex) == 0) {
+            return (255, false);
+        }
+        minIndex = startIndex;
+        // @dev this is a linear search, optimized to start only if there's a set bit at or above startIndex
+        // worst case 255 iterations in memory
+        while (minIndex < 255 && !get(bitMap, uint8(minIndex))) {
+            minIndex++;
+        }
+        foundSetBit = get(bitMap, uint8(minIndex));
+    }
+
+    /**
+     * @notice Finds the index of the highest bit that is set in the bit map
+     * starting from a given index and counting down.
+     * Returns (0, false) if no set bits were found.
+     * @param bitMap BitMap to search
+     * @param startIndex Index to start searching from, inclusive
+     * @return maxIndex Index of last set bit, or 0 if no bits were found
+     * @return foundSetBit True if a set bit was found, false otherwise
+     */
+    function maxBitSet(
+        uint256 bitMap,
+        uint8 startIndex
+    ) internal pure returns (uint256 maxIndex, bool foundSetBit) {
+        if ((bitMap << (255 - startIndex)) == 0) {
+            return (0, false);
+        }
+
+        maxIndex = startIndex;
+        // @dev this is a linear search, worst case 255 iterations in memory
+        while (maxIndex > 0 && !get(bitMap, uint8(maxIndex))) {
+            maxIndex--;
+        }
+        foundSetBit = get(bitMap, uint8(maxIndex));
+    }
+}