@artblocks/contracts 1.0.1 → 1.0.3

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

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Script Storage Library (Reader)
+ * @notice This interface defines the expected read functions for the Art Blocks Script Storage Library (Reader).
+ */
+interface IBytecodeStorageReader {
+    /**
+     * @notice Read a string from contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return data string read from contract bytecode
+     * @dev This function performs input validation that the contract to read is in an expected format
+     */
+    function readFromBytecode(
+        address _address
+    ) external view returns (string memory data);
+
+    /**
+     * @notice Read the bytes from contract bytecode that was written to the EVM using SSTORE2
+     * @param _address address of deployed contract with bytecode stored in the SSTORE2 format
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address _address
+    ) external view returns (bytes memory data);
+
+    /**
+     * @notice Read the bytes from contract bytecode, with an explicitly provided starting offset
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @param _offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromBytecode(
+        address _address,
+        uint256 _offset
+    ) external view returns (bytes memory data);
+
+    /**
+     * @notice Get address for deployer for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return writerAddress address read from contract bytecode
+     */
+    function getWriterAddressForBytecode(
+        address _address
+    ) external view returns (address);
+
+    /**
+     * @notice Get version for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return version version read from contract bytecode
+     */
+    function getLibraryVersionForBytecode(
+        address _address
+    ) external view returns (bytes32);
+}

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

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+pragma solidity ^0.8.0;
+
+import "./IEngineRegistryV0.sol";
+
+interface ICoreRegistryV1 is IEngineRegistryV0 {
+    function registerContracts(
+        address[] calldata _contractAddresses,
+        bytes32[] calldata _coreVersions,
+        bytes32[] calldata _coreTypes
+    ) external;
+
+    function unregisterContracts(
+        address[] calldata _contractAddresses
+    ) external;
+
+    function getNumRegisteredContracts() external view returns (uint256);
+
+    function getRegisteredContractAt(
+        uint256 _index
+    ) external view returns (address);
+
+    function isRegisteredContract(
+        address _contractAddress
+    ) external view returns (bool isRegistered);
+}

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CC0-1.0
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.19;
 
 /// @dev Source: https://github.com/0xfoobar/delegation-registry/blob/main/src/IDelegationRegistry.sol
 

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.19;
 
 interface IDependencyRegistryCompatibleV0 {
     /// Dependency registry managed by Art Blocks

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.19;
 
 interface IDependencyRegistryV0 {
     event SupportedCoreContractAdded(address indexed _coreContractAddress);

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.0;
 
 interface IEngineRegistryV0 {
     /// ADDRESS

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

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: GPL-3.0
+// Created By: Art Blocks Inc.
+
+import "./IFilteredMinterV2.sol";
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Interface for MinterSEA, inspired by nouns.wtf.
+ * This interface combines the set of interfaces that add support for
+ * a Serial English Auction Minter.
+ * @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
+        uint256 tokenId;
+        // 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;
+    }
+
+    /// Admin-controlled range of allowed auction durations updated
+    event AuctionDurationSecondsRangeUpdated(
+        uint32 minAuctionDurationSeconds,
+        uint32 maxAuctionDurationSeconds
+    );
+
+    /// Admin-controlled minimum bid increment percentage updated
+    event MinterMinBidIncrementPercentageUpdated(
+        uint8 minterMinBidIncrementPercentage
+    );
+
+    /// Admin-controlled time buffer updated
+    event MinterTimeBufferUpdated(uint32 minterTimeBufferSeconds);
+
+    // Admin-controlled refund gas limit updated
+    event MinterRefundGasLimitUpdated(uint16 refundGasLimit);
+
+    /// Artist configured future auction details
+    event ConfiguredFutureAuctions(
+        uint256 indexed projectId,
+        uint64 timestampStart,
+        uint32 auctionDurationSeconds,
+        uint256 basePrice
+    );
+
+    /// Future auction details for project `projectId` reset
+    event ResetAuctionDetails(uint256 indexed projectId);
+
+    /// New token auction created, token created and sent to minter
+    event AuctionInitialized(
+        uint256 indexed tokenId,
+        address indexed bidder,
+        uint256 bidAmount,
+        uint64 endTime
+    );
+
+    /// Successful bid placed on token auction
+    event AuctionBid(
+        uint256 indexed tokenId,
+        address indexed bidder,
+        uint256 bidAmount
+    );
+
+    /// Token auction was settled (token distributed to winner)
+    event AuctionSettled(
+        uint256 indexed tokenId,
+        address indexed winner,
+        uint256 price
+    );
+
+    // Next token ID for project `projectId` updated
+    event ProjectNextTokenUpdated(uint256 indexed projectId, uint256 tokenId);
+
+    // Next token ID for project `projectId` was ejected from the minter
+    // and is no longer populated
+    event ProjectNextTokenEjected(uint256 indexed projectId);
+
+    function configureFutureAuctions(
+        uint256 _projectId,
+        uint256 _timestampStart,
+        uint256 _auctionDurationSeconds,
+        uint256 _basePrice
+    ) external;
+
+    function resetAuctionDetails(uint256 _projectId) external;
+
+    // artist-only function that populates the next token ID to be auctioned
+    // for project `projectId`
+    function tryPopulateNextToken(uint256 _projectId) external;
+
+    function settleAuctionAndCreateBid(
+        uint256 _settleTokenId,
+        uint256 _bidTokenId
+    ) external payable;
+
+    function settleAuction(uint256 _tokenId) external;
+
+    function createBid(uint256 _tokenId) external payable;
+
+    function createBid_l34(uint256 _tokenId) external payable;
+
+    function minterConfigurationDetails()
+        external
+        view
+        returns (
+            uint32 minAuctionDurationSeconds_,
+            uint32 maxAuctionDurationSeconds_,
+            uint8 minterMinBidIncrementPercentage_,
+            uint32 minterTimeBufferSeconds_,
+            uint16 minterRefundGasLimit_
+        );
+
+    function projectConfigurationDetails(
+        uint256 _projectId
+    ) external view returns (ProjectConfig memory projectConfiguration_);
+
+    function projectActiveAuctionDetails(
+        uint256 _projectId
+    ) external view returns (Auction memory);
+
+    function getTokenToBid(uint256 _projectId) external view returns (uint256);
+}

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);
 
@@ -100,6 +103,14 @@ interface IGenArt721CoreContractV3_Base is IManifold {
         uint256 _projectId
     ) external view returns (uint256);
 
+    function projectIdToSecondaryMarketRoyaltyPercentage(
+        uint256 _projectId
+    ) external view returns (uint256);
+
+    function projectURIInfo(
+        uint256 _projectId
+    ) external view returns (string memory projectBaseURI);
+
     // @dev new function in V3
     function projectStateData(
         uint256 _projectId
@@ -115,6 +126,37 @@ interface IGenArt721CoreContractV3_Base is IManifold {
             bool locked
         );
 
+    function projectDetails(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            string memory projectName,
+            string memory artist,
+            string memory description,
+            string memory website,
+            string memory license
+        );
+
+    function projectScriptDetails(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            string memory scriptTypeAndVersion,
+            string memory aspectRatio,
+            uint256 scriptCount
+        );
+
+    function projectScriptByIndex(
+        uint256 _projectId,
+        uint256 _index
+    ) external view returns (string memory);
+
+    function tokenIdToHash(uint256 _tokenId) external view returns (bytes32);
+
     // function to set a token's hash (must be guarded)
     function setTokenHash_8PT(uint256 _tokenId, bytes32 _hash) external;
 

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

@@ -69,12 +69,4 @@ interface IGenArt721CoreContractV3_Engine is IGenArt721CoreContractV3_Base {
         external
         view
         returns (uint256);
-
-    // function to read the hash for a given tokenId
-    function tokenIdToHash(uint256 _tokenId) external view returns (bytes32);
-
-    // 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_Engine_Flex.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import "./IAdminACLV0.sol";
+import "./IGenArt721CoreContractV3_Engine.sol";
+
+/**
+ * @title This interface is intended to house interface items that are common
+ * across all GenArt721CoreContractV3 Engine Flex and derivative implementations.
+ * @author Art Blocks Inc.
+ */
+interface IGenArt721CoreContractV3_Engine_Flex is
+    IGenArt721CoreContractV3_Engine
+{
+    /**
+     * @notice When an external asset dependency is updated or added, this event is emitted.
+     * @param _projectId The project ID of the project that was updated.
+     * @param _index The index of the external asset dependency that was updated.
+     * @param _cid The content ID of the external asset dependency. This is an empty string
+     * if the dependency type is ONCHAIN.
+     * @param _dependencyType The type of the external asset dependency.
+     * @param _externalAssetDependencyCount The number of external asset dependencies.
+     */
+    event ExternalAssetDependencyUpdated(
+        uint256 indexed _projectId,
+        uint256 indexed _index,
+        string _cid,
+        ExternalAssetDependencyType _dependencyType,
+        uint24 _externalAssetDependencyCount
+    );
+
+    /**
+     * @notice The project id `_projectId` has had an external asset dependency removed at index `_index`.
+     */
+    event ExternalAssetDependencyRemoved(
+        uint256 indexed _projectId,
+        uint256 indexed _index
+    );
+
+    /**
+     * @notice The preferred gateway for dependency type `_dependencyType` has been updated to `_gatewayAddress`.
+     */
+    event GatewayUpdated(
+        ExternalAssetDependencyType indexed _dependencyType,
+        string _gatewayAddress
+    );
+
+    /**
+     * @notice The project id `_projectId` has had all external asset dependencies locked.
+     * @dev This is a one-way operation. Once locked, the external asset dependencies cannot be updated.
+     */
+    event ProjectExternalAssetDependenciesLocked(uint256 indexed _projectId);
+
+    /**
+     * @notice An external asset dependency type. Can be one of IPFS, ARWEAVE, or ONCHAIN.
+     */
+    enum ExternalAssetDependencyType {
+        IPFS,
+        ARWEAVE,
+        ONCHAIN
+    }
+
+    /**
+     * @notice An external asset dependency. This is a struct that contains the CID of the dependency,
+     * the type of the dependency, and the address of the bytecode for this dependency.
+     */
+    struct ExternalAssetDependency {
+        string cid;
+        ExternalAssetDependencyType dependencyType;
+        address bytecodeAddress;
+    }
+
+    /**
+     * @notice An external asset dependency with data. This is a convenience struct that contains the CID of the dependency,
+     * the type of the dependency, the address of the bytecode for this dependency, and the data retrieved from this bytecode address.
+     */
+    struct ExternalAssetDependencyWithData {
+        string cid;
+        ExternalAssetDependencyType dependencyType;
+        address bytecodeAddress;
+        string data;
+    }
+
+    // preferredIPFSGateway is a url string
+    function preferredIPFSGateway() external view returns (string memory);
+
+    // preferredArweaveGateway is a url string
+    function preferredArweaveGateway() external view returns (string memory);
+
+    // updates the preferred IPFS gateway
+    function updateIPFSGateway(string calldata _gateway) external;
+
+    // updates the preferred Arweave gateway
+    function updateArweaveGateway(string calldata _gateway) external;
+
+    // locks the external asset dependencies for a project
+    function lockProjectExternalAssetDependencies(uint256 _projectId) external;
+
+    // updates the external asset dependency for a project at a given index
+    function updateProjectExternalAssetDependency(
+        uint256 _projectId,
+        uint256 _index,
+        string memory _cidOrData,
+        ExternalAssetDependencyType _dependencyType
+    ) external;
+
+    // adds an external asset dependency for a project
+    function addProjectExternalAssetDependency(
+        uint256 _projectId,
+        string memory _cidOrData,
+        ExternalAssetDependencyType _dependencyType
+    ) external;
+
+    // removes an external asset dependency for a project at a given index
+    function removeProjectExternalAssetDependency(
+        uint256 _projectId,
+        uint256 _index
+    ) external;
+
+    // getter function for project external asset dependencies
+    function projectExternalAssetDependencyByIndex(
+        uint256 _projectId,
+        uint256 _index
+    ) external view returns (ExternalAssetDependencyWithData memory);
+
+    // getter function project external asset dependency count
+    function projectExternalAssetDependencyCount(
+        uint256 _projectId
+    ) external view returns (uint256);
+}

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);
+}