@artblocks/contracts 0.0.1 → 1.0.1

package/contracts/interfaces/0.8.x/IMintingAPICoreV0.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/* Provides an interface definition for compatibility with the Minting API.
+ *
+ * In order for a core contract to be compatible with the REST API provided
+ * at https://minting-api.artblocks.io/ it must implement the interface defined
+ * below.
+ */
+interface IMintingAPICoreV0 {
+    /**
+     * @notice Token ID `_tokenId` minted on project ID `_projectId` to `_to`.
+     */
+    event Mint(
+        address indexed _to,
+        uint256 indexed _tokenId,
+        uint256 indexed _projectId
+    );
+
+    // getter function of public variable
+    function nextProjectId() external view returns (uint256);
+
+    function projectDetails(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            string memory projectName,
+            string memory artist,
+            string memory description,
+            string memory website,
+            string memory license
+        );
+
+    function projectIdToPricePerTokenInWei(
+        uint256 _projectId
+    ) external view returns (uint256);
+
+    function projectTokenInfo(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            address,
+            uint256,
+            uint256,
+            uint256,
+            bool,
+            address,
+            uint256,
+            string memory,
+            address
+        );
+
+    function tokensOfOwner(
+        address owner
+    ) external view returns (uint256[] memory);
+}

package/contracts/interfaces/0.8.x/IMintingAPIMinterV0.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/* Provides an interface definition for compatibility with the Minting API.
+ *
+ * In order for a minter contract to be compatible with the REST API provided
+ * at https://minting-api.artblocks.io/ it must implement the interface defined
+ * below.
+ */
+interface IMintingAPIMinterV0 {
+    function projectMaxHasBeenInvoked(uint256) external returns (bool);
+
+    function purchaseTo(
+        address _to,
+        uint256 _projectId
+    ) external returns (uint256 _tokenId);
+
+    function getPriceInfo(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        );
+}

package/contracts/interfaces/0.8.x/IRandomizerPolyptychV0.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity 0.8.17;
+
+import "./IRandomizerV2.sol";
+
+interface IRandomizerPolyptychV0 is IRandomizerV2 {
+    /**
+     * @notice Minter contract at `_contractAddress` allowed to assign token hash seeds.
+     */
+    event HashSeedSetterUpdated(address indexed _contractAddress);
+
+    /**
+     * @notice Project with ID `_projectId` is enabled/disabled for polyptych minting.
+     */
+    event ProjectIsPolyptychUpdated(uint256 _projectId, bool _isPolyptych);
+
+    /**
+     * @notice When a core contract calls this, it can be assured that the randomizer
+     * will set a bytes32 hash for tokenId `_tokenId` on the core contract. This function
+     * may only be called by the contract configured as the `hashSeedSetterContract` via
+     * the `setHashSeedSetterContract` available to the core contract admin.
+     */
+    function assignTokenHash(uint256 _tokenId) external;
+
+    /**
+     * @notice Store the token hash seed for an existing token to be re-used in a polyptych panel.
+     */
+    function setPolyptychHashSeed(uint256 _tokenId, bytes12 _hashSeed) external;
+}

package/contracts/interfaces/0.8.x/IRandomizerV2.sol

@@ -3,11 +3,14 @@
 
 pragma solidity ^0.8.0;
 
-import "./IGenArt721CoreContractV3.sol";
+import "./IGenArt721CoreContractV3_Base.sol";
 
 interface IRandomizerV2 {
     // The core contract that may interact with this randomizer contract.
-    function genArt721Core() external view returns (IGenArt721CoreContractV3);
+    function genArt721Core()
+        external
+        view
+        returns (IGenArt721CoreContractV3_Base);
 
     // When a core contract calls this, it can be assured that the randomizer
     // will set a bytes32 hash for tokenId `_tokenId` on the core contract.

package/contracts/minter-suite/MinterFilter/MinterFilterV1.sol

@@ -6,6 +6,8 @@ import "../../interfaces/0.8.x/IFilteredMinterV0.sol";
 import "../../interfaces/0.8.x/IAdminACLV0.sol";
 import "../../interfaces/0.8.x/IGenArt721CoreContractV3.sol";
 
+import "../../libs/0.8.x/Bytes32Strings.sol";
+
 import "@openzeppelin-4.5/contracts/utils/structs/EnumerableMap.sol";
 
 pragma solidity 0.8.17;
@@ -39,6 +41,21 @@ pragma solidity 0.8.17;
 contract MinterFilterV1 is IMinterFilterV0 {
     // add Enumerable Map methods
     using EnumerableMap for EnumerableMap.UintToAddressMap;
+    // add Bytes32Strings methods
+    using Bytes32Strings for bytes32;
+
+    /// version & type of this core contract
+    bytes32 constant MINTER_FILTER_VERSION = "v1.0.1";
+
+    function minterFilterVersion() external pure returns (string memory) {
+        return MINTER_FILTER_VERSION.toString();
+    }
+
+    bytes32 constant MINTER_FILTER_TYPE = "MinterFilterV1";
+
+    function minterFilterType() external pure returns (string memory) {
+        return MINTER_FILTER_TYPE.toString();
+    }
 
     /// Core contract address this minter interacts with
     address public immutable genArt721CoreAddress;
@@ -106,6 +123,7 @@ contract MinterFilterV1 is IMinterFilterV0 {
     ) onlyNonZeroAddress(_genArt721Address) {
         genArt721CoreAddress = _genArt721Address;
         genArtCoreContract = IGenArt721CoreContractV3(_genArt721Address);
+        emit Deployed();
     }
 
     /**

package/contracts/minter-suite/Minters/MinterBase_v0_1_1.sol

@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../../interfaces/0.8.x/IMinterBaseV0.sol";
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3.sol";
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Engine.sol";
+
+import "@openzeppelin-4.7/contracts/token/ERC20/IERC20.sol";
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Minter Base Class
+ * @notice A base class for Art Blocks minter contracts that provides common
+ * functionality used across minter contracts.
+ * This contract is not intended to be deployed directly, but rather to be
+ * inherited by other minter contracts.
+ * From a design perspective, this contract is intended to remain simple and
+ * easy to understand. It is not intended to cause a complex inheritance tree,
+ * and instead should keep minter contracts as readable as possible for
+ * collectors and developers.
+ * @dev Semantic versioning is used in the solidity file name, and is therefore
+ * controlled by contracts importing the appropriate filename version.
+ * @author Art Blocks Inc.
+ */
+abstract contract MinterBase is IMinterBaseV0 {
+    /// state variable that tracks whether this contract's associated core
+    /// contract is an Engine contract, where Engine contracts have an
+    /// additional revenue split for the platform provider
+    bool public immutable isEngine;
+
+    // @dev we do not track an initialization state, as the only state variable
+    // is immutable, which the compiler enforces to be assigned during
+    // construction.
+
+    /**
+     * @notice Initializes contract to ensure state variable `isEngine` is set
+     * appropriately based on the minter's associated core contract address.
+     * @param genArt721Address Art Blocks core contract address for
+     * which this contract will be a minter.
+     */
+    constructor(address genArt721Address) {
+        // set state variable isEngine
+        isEngine = _getV3CoreIsEngine(genArt721Address);
+    }
+
+    /**
+     * @notice splits ETH funds between sender (if refund), providers,
+     * artist, and artist's additional payee for a token purchased on
+     * project `_projectId`.
+     * WARNING: This function uses msg.value and msg.sender to determine
+     * refund amounts, and therefore may not be applicable to all use cases
+     * (e.g. do not use with Dutch Auctions with on-chain settlement).
+     * @dev possible DoS during splits is acknowledged, and mitigated by
+     * business practices, including end-to-end testing on mainnet, and
+     * admin-accepted artist payment addresses.
+     * @param projectId Project ID for which funds shall be split.
+     * @param pricePerTokenInWei Current price of token, in Wei.
+     */
+    function splitFundsETH(
+        uint256 projectId,
+        uint256 pricePerTokenInWei,
+        address genArt721CoreAddress
+    ) internal {
+        if (msg.value > 0) {
+            bool success_;
+            // send refund to sender
+            uint256 refund = msg.value - pricePerTokenInWei;
+            if (refund > 0) {
+                (success_, ) = msg.sender.call{value: refund}("");
+                require(success_, "Refund failed");
+            }
+            // split revenues
+            splitRevenuesETH(
+                projectId,
+                pricePerTokenInWei,
+                genArt721CoreAddress
+            );
+        }
+    }
+
+    /**
+     * @notice splits ETH revenues between providers, artist, and artist's
+     * additional payee for revenue generated by project `_projectId`.
+     * @dev possible DoS during splits is acknowledged, and mitigated by
+     * business practices, including end-to-end testing on mainnet, and
+     * admin-accepted artist payment addresses.
+     * @param projectId Project ID for which funds shall be split.
+     * @param valueInWei Value to be split, in Wei.
+     */
+    function splitRevenuesETH(
+        uint256 projectId,
+        uint256 valueInWei,
+        address genArtCoreContract
+    ) internal {
+        if (valueInWei <= 0) {
+            return; // return early
+        }
+        bool success;
+        // split funds between platforms, artist, and artist's
+        // additional payee
+        uint256 renderProviderRevenue_;
+        address payable renderProviderAddress_;
+        uint256 artistRevenue_;
+        address payable artistAddress_;
+        uint256 additionalPayeePrimaryRevenue_;
+        address payable additionalPayeePrimaryAddress_;
+        if (isEngine) {
+            // get engine splits
+            uint256 platformProviderRevenue_;
+            address payable platformProviderAddress_;
+            (
+                renderProviderRevenue_,
+                renderProviderAddress_,
+                platformProviderRevenue_,
+                platformProviderAddress_,
+                artistRevenue_,
+                artistAddress_,
+                additionalPayeePrimaryRevenue_,
+                additionalPayeePrimaryAddress_
+            ) = IGenArt721CoreContractV3_Engine(genArtCoreContract)
+                .getPrimaryRevenueSplits(projectId, valueInWei);
+            // Platform Provider payment (only possible if engine)
+            if (platformProviderRevenue_ > 0) {
+                (success, ) = platformProviderAddress_.call{
+                    value: platformProviderRevenue_
+                }("");
+                require(success, "Platform Provider payment failed");
+            }
+        } else {
+            // get flagship splits
+            (
+                renderProviderRevenue_, // artblocks revenue
+                renderProviderAddress_, // artblocks address
+                artistRevenue_,
+                artistAddress_,
+                additionalPayeePrimaryRevenue_,
+                additionalPayeePrimaryAddress_
+            ) = IGenArt721CoreContractV3(genArtCoreContract)
+                .getPrimaryRevenueSplits(projectId, valueInWei);
+        }
+        // Render Provider / Art Blocks payment
+        if (renderProviderRevenue_ > 0) {
+            (success, ) = renderProviderAddress_.call{
+                value: renderProviderRevenue_
+            }("");
+            require(success, "Render Provider payment failed");
+        }
+        // artist payment
+        if (artistRevenue_ > 0) {
+            (success, ) = artistAddress_.call{value: artistRevenue_}("");
+            require(success, "Artist payment failed");
+        }
+        // additional payee payment
+        if (additionalPayeePrimaryRevenue_ > 0) {
+            (success, ) = additionalPayeePrimaryAddress_.call{
+                value: additionalPayeePrimaryRevenue_
+            }("");
+            require(success, "Additional Payee payment failed");
+        }
+    }
+
+    /**
+     * @notice splits ERC-20 funds between providers, artist, and artist's
+     * additional payee, for a token purchased on project `_projectId`.
+     * @dev possible DoS during splits is acknowledged, and mitigated by
+     * business practices, including end-to-end testing on mainnet, and
+     * admin-accepted artist payment addresses.
+     */
+    function splitFundsERC20(
+        uint256 projectId,
+        uint256 pricePerTokenInWei,
+        address currencyAddress,
+        address genArtCoreContract
+    ) internal {
+        IERC20 _projectCurrency = IERC20(currencyAddress);
+        // split remaining funds between foundation, artist, and artist's
+        // additional payee
+        uint256 renderProviderRevenue_;
+        address payable renderProviderAddress_;
+        uint256 artistRevenue_;
+        address payable artistAddress_;
+        uint256 additionalPayeePrimaryRevenue_;
+        address payable additionalPayeePrimaryAddress_;
+        if (isEngine) {
+            // get engine splits
+            uint256 platformProviderRevenue_;
+            address payable platformProviderAddress_;
+            (
+                renderProviderRevenue_,
+                renderProviderAddress_,
+                platformProviderRevenue_,
+                platformProviderAddress_,
+                artistRevenue_,
+                artistAddress_,
+                additionalPayeePrimaryRevenue_,
+                additionalPayeePrimaryAddress_
+            ) = IGenArt721CoreContractV3_Engine(genArtCoreContract)
+                .getPrimaryRevenueSplits(projectId, pricePerTokenInWei);
+            // Platform Provider payment (only possible if engine)
+            if (platformProviderRevenue_ > 0) {
+                _projectCurrency.transferFrom(
+                    msg.sender,
+                    platformProviderAddress_,
+                    platformProviderRevenue_
+                );
+            }
+        } else {
+            // get flagship splits
+            (
+                renderProviderRevenue_, // artblocks revenue
+                renderProviderAddress_, // artblocks address
+                artistRevenue_,
+                artistAddress_,
+                additionalPayeePrimaryRevenue_,
+                additionalPayeePrimaryAddress_
+            ) = IGenArt721CoreContractV3(genArtCoreContract)
+                .getPrimaryRevenueSplits(projectId, pricePerTokenInWei);
+        }
+        // Art Blocks payment
+        if (renderProviderRevenue_ > 0) {
+            _projectCurrency.transferFrom(
+                msg.sender,
+                renderProviderAddress_,
+                renderProviderRevenue_
+            );
+        }
+        // artist payment
+        if (artistRevenue_ > 0) {
+            _projectCurrency.transferFrom(
+                msg.sender,
+                artistAddress_,
+                artistRevenue_
+            );
+        }
+        // additional payee payment
+        if (additionalPayeePrimaryRevenue_ > 0) {
+            _projectCurrency.transferFrom(
+                msg.sender,
+                additionalPayeePrimaryAddress_,
+                additionalPayeePrimaryRevenue_
+            );
+        }
+    }
+
+    /**
+     * @notice Returns whether a V3 core contract is an Art Blocks Engine
+     * contract or not. Return value of false indicates that the core is a
+     * flagship contract.
+     * @dev this function reverts if a core contract does not return the
+     * expected number of return values from getPrimaryRevenueSplits() for
+     * either a flagship or engine core contract.
+     * @dev this function uses the length of the return data (in bytes) to
+     * determine whether the core is an engine or not.
+     * @param genArt721CoreV3 The address of the deployed core contract.
+     */
+    function _getV3CoreIsEngine(
+        address genArt721CoreV3
+    ) private returns (bool) {
+        // call getPrimaryRevenueSplits() on core contract
+        bytes memory payload = abi.encodeWithSignature(
+            "getPrimaryRevenueSplits(uint256,uint256)",
+            0,
+            0
+        );
+        (bool success, bytes memory returnData) = genArt721CoreV3.call(payload);
+        require(success, "getPrimaryRevenueSplits() call failed");
+        // determine whether core is engine or not, based on return data length
+        uint256 returnDataLength = returnData.length;
+        if (returnDataLength == 6 * 32) {
+            // 6 32-byte words returned if flagship (not engine)
+            // @dev 6 32-byte words are expected because the non-engine core
+            // contracts return a payout address and uint256 payment value for
+            // the artist, and artist's additional payee, and Art Blocks.
+            // also note that per Solidity ABI encoding, the address return
+            // values are padded to 32 bytes.
+            return false;
+        } else if (returnDataLength == 8 * 32) {
+            // 8 32-byte words returned if engine
+            // @dev 8 32-byte words are expected because the engine core
+            // contracts return a payout address and uint256 payment value for
+            // the artist, artist's additional payee, render provider
+            // typically Art Blocks, and platform provider (partner).
+            // also note that per Solidity ABI encoding, the address return
+            // values are padded to 32 bytes.
+            return true;
+        } else {
+            // unexpected return value length
+            revert("Unexpected revenue split bytes");
+        }
+    }
+}