@artblocks/contracts 1.0.2 → 1.0.3

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

@@ -12,6 +12,37 @@ pragma solidity ^0.8.0;
  * @author Art Blocks Inc.
  */
 interface IFilteredMinterSEAV0 is IFilteredMinterV2 {
+    // project-specific parameters
+    struct ProjectConfig {
+        bool maxHasBeenInvoked;
+        // max uint24 ~= 1.6e7, > max possible project invocations of 1e6
+        uint24 maxInvocations;
+        // time after which new auctions may be started
+        // note: new auctions must always be started with a new bid, at which
+        // point the auction will actually start
+        // @dev this is a project-level constraint, and individual auctions
+        // will each have their own start time defined in `activeAuction`
+        // max uint64 ~= 1.8e19 sec ~= 570 billion years
+        uint64 timestampStart;
+        // duration of each new auction, before any extensions due to late bids
+        // @dev for configured auctions, this will be gt 0, so it may be used
+        // to determine if an auction is configured
+        uint32 auctionDurationSeconds;
+        // next token number to be auctioned, owned by minter
+        // @dev store token number to enable storage packing, as token ID can
+        // be derived from this value in combination with project ID
+        // max uint24 ~= 1.6e7, > max possible project invocations of 1e6
+        uint24 nextTokenNumber;
+        // bool to indicate if next token number has been populated, or is
+        // still default value of 0
+        // @dev required to handle edge case where next token number is 0
+        bool nextTokenNumberIsPopulated;
+        // reserve price, i.e. minimum starting bid price, in wei
+        uint256 basePrice;
+        // active auction for project
+        Auction activeAuction;
+    }
+
     /// Struct that defines a single token English auction
     struct Auction {
         // token number of NFT being auctioned
@@ -19,15 +50,14 @@ interface IFilteredMinterSEAV0 is IFilteredMinterV2 {
         // The current highest bid amount (in wei)
         uint256 currentBid;
         // The address of the current highest bidder
+        // @dev if this is not the zero address, then the auction is
+        // considered initialized
         address payable currentBidder;
         // The time that the auction is scheduled to end
         // max uint64 ~= 1.8e19 sec ~= 570 billion years
         uint64 endTime;
         // Whether or not the auction has been settled
         bool settled;
-        // Whether or not the auction has been initialized (used to determine
-        // if auction is the default struct)
-        bool initialized;
     }
 
     /// Admin-controlled range of allowed auction durations updated
@@ -124,18 +154,7 @@ interface IFilteredMinterSEAV0 is IFilteredMinterV2 {
 
     function projectConfigurationDetails(
         uint256 _projectId
-    )
-        external
-        view
-        returns (
-            uint24 maxInvocations,
-            uint64 timestampStart,
-            uint32 auctionDurationSeconds,
-            uint256 basePrice,
-            bool nextTokenNumberIsPopulated,
-            uint24 nextTokenNumber,
-            Auction memory auction
-        );
+    ) external view returns (ProjectConfig memory projectConfiguration_);
 
     function projectActiveAuctionDetails(
         uint256 _projectId

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

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+interface IGenArt721CoreContractExposesHashSeed {
+    // function to read the hash-seed for a given tokenId
+    function tokenIdToHashSeed(
+        uint256 _tokenId
+    ) external view returns (bytes12);
+}

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

@@ -77,6 +77,9 @@ interface IGenArt721CoreContractV3_Base is IManifold {
         bytes4 _selector
     ) external returns (bool);
 
+    /// getter function of public variable
+    function startingProjectId() external view returns (uint256);
+
     // getter function of public variable
     function nextProjectId() external view returns (uint256);
 

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

@@ -69,9 +69,4 @@ interface IGenArt721CoreContractV3_Engine is IGenArt721CoreContractV3_Base {
         external
         view
         returns (uint256);
-
-    // function to read the hash-seed for a given tokenId
-    function tokenIdToHashSeed(
-        uint256 _tokenId
-    ) external view returns (bytes12);
 }

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

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import "./ICoreRegistryV1.sol";
+import "./IAdminACLV0.sol";
+
+/**
+ * @title IMinterFilterV1
+ * @author Art Blocks Inc.
+ * @notice Interface for a new minter filter contract.
+ * This interface does not extend the previous version of the minter filter
+ * interface, as the previous version is not compatible with the new
+ * minter filter architecture.
+ * @dev This interface is for a minter filter that supports multiple core
+ * contracts, and allows for a minter to be set on a per-project basis.
+ */
+interface IMinterFilterV1 {
+    /**
+     * @notice Emitted when contract is deployed to notify indexing services
+     * of the new contract deployment.
+     */
+    event Deployed();
+
+    /**
+     * @notice Globally approved minter `minter`.
+     */
+    event MinterApprovedGlobally(address indexed minter, string minterType);
+
+    /**
+     * @notice Globally revoked minter `minter`.
+     * @dev contract owner may still approve this minter on a per-contract
+     * basis.
+     */
+    event MinterRevokedGlobally(address indexed minter);
+
+    /**
+     * @notice Approved minter `minter` on core contract
+     * `coreContract`.
+     */
+    event MinterApprovedForContract(
+        address indexed coreContract,
+        address indexed minter,
+        string minterType
+    );
+
+    /**
+     * @notice Revoked minter `minter` on core contract `coreContract`.
+     * @dev minter filter owner may still globally approve this minter for all
+     * contracts.
+     */
+    event MinterRevokedForContract(
+        address indexed coreContract,
+        address indexed minter
+    );
+
+    /**
+     * @notice Minter at address `minter` set as minter for project
+     * `projectId` on core contract `coreContract`.
+     */
+    event ProjectMinterRegistered(
+        uint256 indexed projectId,
+        address indexed coreContract,
+        address indexed minter,
+        string minterType
+    );
+
+    /**
+     * @notice Minter removed for project `projectId` on core contract
+     * `coreContract`.
+     */
+    event ProjectMinterRemoved(
+        uint256 indexed projectId,
+        address indexed coreContract
+    );
+
+    /**
+     * @notice Admin ACL contract updated to `adminACLContract`.
+     */
+    event AdminACLUpdated(address indexed adminACLContract);
+
+    /**
+     * @notice Core Registry contract updated to `coreRegistry`.
+     */
+    event CoreRegistryUpdated(address indexed coreRegistry);
+
+    function setMinterForProject(
+        uint256 _projectId,
+        address _coreContract,
+        address _minter
+    ) external;
+
+    function removeMinterForProject(
+        uint256 _projectId,
+        address _coreContract
+    ) external;
+
+    // @dev function name is optimized for gas
+    function mint_joo(
+        address _to,
+        uint256 _projectId,
+        address _coreContract,
+        address _sender
+    ) external returns (uint256);
+
+    function updateCoreRegistry(address _coreRegistry) external;
+
+    function minterFilterType() external pure returns (string memory);
+
+    function getMinterForProject(
+        uint256 _projectId,
+        address _coreContract
+    ) external view returns (address);
+
+    function projectHasMinter(
+        uint256 _projectId,
+        address _coreContract
+    ) external view returns (bool);
+
+    /**
+     * @notice View that returns if a core contract is registered with the
+     * core registry, allowing this minter filter to service it.
+     * @param _coreContract core contract address to be checked
+     */
+    function isRegisteredCoreContract(
+        address _coreContract
+    ) external view returns (bool);
+
+    /// Address of current core registry contract
+    function coreRegistry() external view returns (ICoreRegistryV1);
+
+    /// The current admin ACL contract
+    function adminACLContract() external view returns (IAdminACLV0);
+
+    /// The quantity of projects on a core contract that have assigned minters
+    function getNumProjectsOnContractWithMinters(
+        address _coreContract
+    ) external view returns (uint256);
+
+    function getProjectAndMinterInfoOnContractAt(
+        address _coreContract,
+        uint256 _index
+    )
+        external
+        view
+        returns (
+            uint256 projectId,
+            address minterAddress,
+            string memory minterType
+        );
+
+    /**
+     * Owner of contract.
+     * @dev This returns the address of the Admin ACL contract.
+     */
+    function owner() external view returns (address);
+}

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

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+interface IPseudorandomAtomic {
+    /**
+     * @notice This function atomically returns a pseudorandom bytes32 value.
+     * @param _entropy entropy to be included during the pseudorandom
+     * generation process. An example of entropy might be the hash of a core
+     * contract's address, and the ID of the token being generated.
+     */
+    function getPseudorandomAtomic(
+        bytes32 _entropy
+    ) external view returns (bytes32);
+}

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 import "./IRandomizerV2.sol";
 

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

@@ -4,15 +4,12 @@
 pragma solidity ^0.8.0;
 
 import "./IGenArt721CoreContractV3_Base.sol";
+import "./IRandomizer_V3CoreBase.sol";
 
-interface IRandomizerV2 {
+interface IRandomizerV2 is IRandomizer_V3CoreBase {
     // The core contract that may interact with this randomizer contract.
     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.
-    function assignTokenHash(uint256 _tokenId) external;
 }

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

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+interface IRandomizer_V3CoreBase {
+    // 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.
+    function assignTokenHash(uint256 _tokenId) external;
+}

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

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import "./IRandomizer_V3CoreBase.sol";
+
+interface ISharedRandomizerV0 is IRandomizer_V3CoreBase {
+    /**
+     * @notice The pseudorandom atomic contract that is used to generate
+     * pseudorandom values for this randomizer was updated.
+     */
+    event PseudorandomAtomicContractUpdated(
+        address indexed pseudorandomAtomicContract
+    );
+
+    /**
+     * @notice Minter contract at `_hashSeedSetterContract` allowed to assign
+     * token hash seeds on core contract `_coreContract`.
+     */
+    event HashSeedSetterForCoreUpdated(
+        address indexed coreContract,
+        address indexed hashSeedSetterContract
+    );
+
+    /**
+     * @notice Project with ID `_projectId` is enabled/disabled for polyptych
+     * minting (i.e. allows token hash seeds to be set by hash seed setter).
+     */
+    event ProjectIsPolyptychUpdated(
+        address coreContract,
+        uint256 projectId,
+        bool isPolyptych
+    );
+
+    /**
+     * @notice Allows the owner of a core contract to set the contract that is
+     * allowed to assign hash seeds to tokens. Typically, this is expected to
+     * be a minter contract, such as `MinterPolyptychV1`.
+     * @param _coreContract - the core contract that is being configured
+     * @param _hashSeedSetterContract - the contract that is allowed to assign
+     * hash seeds to tokens
+     */
+    function setHashSeedSetterContract(
+        address _coreContract,
+        address _hashSeedSetterContract
+    ) external;
+
+    /**
+     * @notice Allows the artist of a project to configure as as a polyptych
+     * project.
+     * @param _coreContract - The address of the core contract
+     * @param _projectId - The ID of the project that has a polyptych panel
+     * (second, third, etc.)
+     */
+    function toggleProjectIsPolyptych(
+        address _coreContract,
+        uint256 _projectId
+    ) external;
+
+    /**
+     * @notice Store the token hash seed for an existing token to be re-used in
+     * a polyptych panel.
+     * @param _coreContract - The address of the core contract of `_tokenId`
+     * @param _tokenId - The ID of the token to set the hash seed for
+     * @param _hashSeed - The hash seed to set for `_tokenId`
+     * @dev Only callable by the hash seed setter contract of `_coreContract`.
+     */
+    function setPolyptychHashSeed(
+        address _coreContract,
+        uint256 _tokenId,
+        bytes12 _hashSeed
+    ) external;
+
+    /**
+     * @notice Boolean representing whether or not project with ID `_projectId`
+     * on core contract `_coreContract` is currently enabled for polyptych
+     * minting.
+     */
+    function projectIsPolyptych(
+        address _coreContract,
+        uint256 _projectId
+    ) external view returns (bool _isPolyptych);
+
+    /**
+     * Returns the hash seed setter contract for a given core contract.
+     * Returns address(0) if no hash seed setter contract is set for the core.
+     * @param _coreContract - The address of the core contract
+     */
+    function hashSeedSetterContracts(
+        address _coreContract
+    ) external view returns (address _hashSeedSetterContract);
+
+    /**
+     * Returns the current hash seed for a given token ID.
+     * Returns bytes12(0) if no hash seed is set for the token.
+     * @param _coreContract - The address of the core contract of `_tokenId`
+     * @param _tokenId - The ID of the token to get the hash seed for
+     * @return _hashSeed - The stored hash seed for `_tokenId`
+     */
+    function polyptychHashSeed(
+        address _coreContract,
+        uint256 _tokenId
+    ) external view returns (bytes12 _hashSeed);
+}