@artblocks/contracts 1.0.3 → 1.1.0

package/contracts/interfaces/v0.8.x/ISharedRandomizerV0.sol

@@ -0,0 +1,123 @@
+// 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 Contract at `hashSeedSetterContract` allowed to assign
+     * token hash seeds on core contract `coreContract` for project
+     * `projectId`.
+     */
+    event HashSeedSetterForProjectUpdated(
+        address indexed coreContract,
+        uint256 indexed projectId,
+        address indexed hashSeedSetterContract
+    );
+
+    /**
+     * @notice Project with ID `projectId` is is or is not using a hash seed
+     * setter contract to assign token hash seeds on core contract.
+     */
+    event ProjectUsingHashSeedSetterUpdated(
+        address coreContract,
+        uint256 projectId,
+        bool usingHashSeedSetter
+    );
+
+    /**
+     * @notice Allows the artist of a project 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 projectId - the project ID that is being configured
+     * @param hashSeedSetterContract - the contract that is allowed to assign
+     * hash seeds to tokens
+     */
+    function setHashSeedSetterContract(
+        address coreContract,
+        uint256 projectId,
+        address hashSeedSetterContract
+    ) external;
+
+    /**
+     * @notice Allows the artist of a project to configure their project to
+     * only allow the specified hash seed setter contract to assign new token
+     * hash seeds. When this is enabled, the hash seed setter contract is
+     * responsible for assigning hash seeds to tokens, and the randomizer
+     * contract will not use the pseudorandom atomic contract to generate
+     * hash seeds.
+     * An example use case is where the artist wants to mint a polyptych panel
+     * (second, third, etc.) of a project, and therefore wants to re-use
+     * specific hash seeds of the original project.
+     * @param coreContract - The address of the core contract
+     * @param projectId - The ID of the project to be toggled
+     */
+    function toggleProjectUseAssignedHashSeed(
+        address coreContract,
+        uint256 projectId
+    ) external;
+
+    /**
+     * @notice Pre-set the hash seed for a token. This function is only
+     * callable by the hash seed setter contract of the project.
+     * @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 preSetHashSeed(
+        address coreContract,
+        uint256 tokenId,
+        bytes12 hashSeed
+    ) external;
+
+    /**
+     * @notice Boolean representing whether or not project with ID `projectId`
+     * on core contract `coreContract` is currently using a hash seed setter
+     * contract to assign hash seeds to tokens.
+     */
+    function projectUsesHashSeedSetter(
+        address coreContract,
+        uint256 projectId
+    ) external view returns (bool usingHashSeedSetter);
+
+    /**
+     * 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
+     * @param projectId - The ID of the project to query
+     */
+    function hashSeedSetterContracts(
+        address coreContract,
+        uint256 projectId
+    ) external view returns (address hashSeedSetterContract);
+
+    /**
+     * Returns the current pre-assigned hash seed for a given token ID.
+     * Returns bytes12(0) if no hash seed has been set for the token.
+     * Note that this only returns the pre-assigned hash seed for tokens that
+     * are configured to use a hash seed setter contract. In typical cases
+     * where the project is not configured to use a hash seed setter contract,
+     * the hash seed is generated on-chain by the pseudorandom atomic contract
+     * and is not stored on-chain in this randomizer contract, and therefore
+     * this function will return bytes12(0).
+     * @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 preAssignedHashSeed(
+        address coreContract,
+        uint256 tokenId
+    ) external view returns (bytes12 hashSeed);
+}

package/contracts/legacy/GenArt721CoreV1.sol

@@ -7,8 +7,8 @@
  *   maintains conforming V1 core contract interface
  */
 
-import "../interfaces/0.5.x/IRandomizer.sol";
-import "../interfaces/0.5.x/IGenArt721CoreContractV1.sol";
+import "../interfaces/v0.5.x/IRandomizer.sol";
+import "../interfaces/v0.5.x/IGenArt721CoreContractV1.sol";
 
 /// -----------------------------------------------------
 /**

package/contracts/legacy/GenArt721LegacyMinter.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-import "../libs/0.5.x/SafeMath.sol";
-import "../libs/0.5.x/Strings.sol";
-import "../libs/0.5.x/IERC20.sol";
+import "../libs/v0.5.x/SafeMath.sol";
+import "../libs/v0.5.x/Strings.sol";
+import "../libs/v0.5.x/IERC20.sol";
 
-import "../interfaces/0.5.x/IGenArt721CoreContractV1.sol";
-import "../interfaces/0.5.x/IBonusContract.sol";
+import "../interfaces/v0.5.x/IGenArt721CoreContractV1.sol";
+import "../interfaces/v0.5.x/IBonusContract.sol";
 
 pragma solidity ^0.5.0;
 

package/contracts/libs/integration-refs/delegation-registry/DelegationRegistry.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.8.19;
 // The source code is copied from ETH mainnet, deployed at:0x00000000000076a84fef008cdabe6409d2fe638b
 // Updates are made to imports for compatibility with this repo.
 
-import "../../../interfaces/0.8.x/IDelegationRegistry.sol";
+import "../../../interfaces/v0.8.x/IDelegationRegistry.sol";
 import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
 import "@openzeppelin-4.7/contracts/utils/introspection/ERC165.sol";
 

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

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Helpers Library
+ * @notice This library contains helper functions for common operations in the
+ * Art Blocks ecosystem of smart contracts.
+ * @author Art Blocks Inc.
+ */
+
+library ABHelpers {
+    uint256 constant ONE_MILLION = 1_000_000;
+
+    /**
+     * @notice Function to convert token id to project id.
+     * @param tokenId The id of the token.
+     */
+    function tokenIdToProjectId(
+        uint256 tokenId
+    ) internal pure returns (uint256) {
+        // int division properly rounds down
+        // @dev unchecked because will never divide by zero
+        unchecked {
+            return tokenId / ONE_MILLION;
+        }
+    }
+
+    /**
+     * @notice Function to convert token id to token number.
+     * @param tokenId The id of the token.
+     */
+    function tokenIdToTokenNumber(
+        uint256 tokenId
+    ) internal pure returns (uint256) {
+        // mod returns remainder, which is the token number
+        // @dev no way to disable mod zero check in solidity, so not unchecked
+        return tokenId % ONE_MILLION;
+    }
+
+    /**
+     * @notice Function to convert project id and token number to token id.
+     * @param projectId The id of the project.
+     * @param tokenNumber The token number.
+     */
+    function tokenIdFromProjectIdAndTokenNumber(
+        uint256 projectId,
+        uint256 tokenNumber
+    ) internal pure returns (uint256) {
+        // @dev intentionally not unchecked to ensure overflow detection, which
+        // would likley only occur in a malicious call
+        return (projectId * ONE_MILLION) + tokenNumber;
+    }
+}

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

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import {IGenArt721CoreContractV3_Base} from "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
+import {IMinterFilterV1} from "../../interfaces/v0.8.x/IMinterFilterV1.sol";
+
+/**
+ * @title Art Blocks Authorization Minter Library
+ * @notice This library contains helper functions that may be used contracts to
+ * check authorization for performing operations in the Art Blocks V3 core
+ * contract ecosystem.
+ * @author Art Blocks Inc.
+ */
+
+library AuthLib {
+    /**
+     * @notice Function to restrict access to only AdminACL allowed calls, where
+     * AdminACL is the admin of an IMinterFilterV1.
+     * Reverts if not allowed.
+     * @param minterFilterAddress address of the minter filter to be checked,
+     * should implement IMinterFilterV1
+     * @param sender address of the caller
+     * @param contract_ address of the contract being called
+     * @param selector selector of the function being called
+     */
+    function onlyMinterFilterAdminACL(
+        address minterFilterAddress,
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) internal {
+        require(
+            _minterFilterAdminACLAllowed({
+                minterFilterAddress: minterFilterAddress,
+                sender: sender,
+                contract_: contract_,
+                selector: selector
+            }),
+            "Only MinterFilter AdminACL"
+        );
+    }
+
+    /**
+     * @notice Function to restrict access to only AdminACL allowed calls, where
+     * AdminACL is the admin of a core contract at `coreContract`.
+     * Reverts if not allowed.
+     * @param coreContract address of the core contract to be checked
+     * @param sender address of the caller
+     * @param contract_ address of the contract being called
+     * @param selector selector of the function being called
+     */
+    function onlyCoreAdminACL(
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) internal {
+        require(
+            _coreAdminACLAllowed({
+                coreContract: coreContract,
+                sender: sender,
+                contract_: contract_,
+                selector: selector
+            }),
+            "Only Core AdminACL allowed"
+        );
+    }
+
+    /**
+     * @notice Throws if `sender` is any account other than the artist of the
+     * specified project `projectId` on core contract `coreContract`.
+     * @param projectId The ID of the project being checked.
+     * @param coreContract The address of the GenArt721CoreContractV3_Base
+     * contract.
+     * @param sender Wallet to check. Typically, the address of the caller.
+     * @dev `sender` must be the artist associated with `projectId` on `coreContract`.
+     */
+    function onlyArtist(
+        uint256 projectId,
+        address coreContract,
+        address sender
+    ) internal view {
+        require(
+            _senderIsArtist({
+                projectId: projectId,
+                coreContract: coreContract,
+                sender: sender
+            }),
+            "Only Artist"
+        );
+    }
+
+    /**
+     * @notice Function to restrict access to only the artist of a project, or AdminACL
+     * allowed calls, where AdminACL is the admin of a core contract at
+     * `coreContract`.
+     * @param projectId id of the project
+     * @param coreContract address of the core contract to be checked
+     * @param sender address of the caller
+     * @param contract_ address of the contract being called
+     * @param selector selector of the function being called
+     */
+    function onlyCoreAdminACLOrArtist(
+        uint256 projectId,
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) internal {
+        require(
+            _senderIsArtist({
+                projectId: projectId,
+                coreContract: coreContract,
+                sender: sender
+            }) ||
+                _coreAdminACLAllowed({
+                    coreContract: coreContract,
+                    sender: sender,
+                    contract_: contract_,
+                    selector: selector
+                }),
+            "Only Artist or Core Admin ACL"
+        );
+    }
+
+    // ------------------------------------------------------------------------
+    // Private functions used internally by this library
+    // ------------------------------------------------------------------------
+
+    /**
+     * @notice Private function that returns if minter filter contract's AdminACL
+     * allows `sender` to call function with selector `selector` on contract
+     * `contract`.
+     * @param minterFilterAddress address of the minter filter to be checked.
+     * Should implement IMinterFilterV1.
+     * @param sender address of the caller
+     * @param contract_ address of the contract being called
+     * @param selector selector of the function being called
+     */
+    function _minterFilterAdminACLAllowed(
+        address minterFilterAddress,
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) private returns (bool) {
+        return
+            IMinterFilterV1(minterFilterAddress).adminACLAllowed({
+                sender: sender,
+                contract_: contract_,
+                selector: selector
+            });
+    }
+
+    /**
+     * @notice Private function that returns if core contract's AdminACL allows
+     * `sender` to call function with selector `selector` on contract
+     * `contract`.
+     * @param coreContract address of the core contract to be checked
+     * @param sender address of the caller
+     * @param contract_ address of the contract being called
+     * @param selector selector of the function being called
+     */
+    function _coreAdminACLAllowed(
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) private returns (bool) {
+        return
+            IGenArt721CoreContractV3_Base(coreContract).adminACLAllowed({
+                _sender: sender,
+                _contract: contract_,
+                _selector: selector
+            });
+    }
+
+    /**
+     * @notice Private function that returns if `sender` is the artist of `projectId`
+     * on `coreContract`.
+     * @param projectId project ID to check
+     * @param coreContract core contract to check
+     * @param sender wallet to check
+     */
+    function _senderIsArtist(
+        uint256 projectId,
+        address coreContract,
+        address sender
+    ) private view returns (bool senderIsArtist) {
+        return
+            sender ==
+            IGenArt721CoreContractV3_Base(coreContract)
+                .projectIdToArtistAddress(projectId);
+    }
+}

package/contracts/libs/{0.8.x → v0.8.x}/Bytes32Strings.sol

@@ -9,13 +9,13 @@ pragma solidity ^0.8.0;
  */
 library Bytes32Strings {
     /**
-     * @dev Intended to convert a `bytes32`-encoded string literal to `string`.
+     * @notice Intended to convert a `bytes32`-encoded string literal to `string`.
      * Trims zero padding to arrive at original string literal.
      */
     function toString(
         bytes32 source
     ) internal pure returns (string memory result) {
-        uint8 length = 0;
+        uint8 length;
         while (source[length] != 0 && length < 32) {
             length++;
         }
@@ -33,7 +33,7 @@ library Bytes32Strings {
     }
 
     /**
-     * @dev Intended to check if a `bytes32`-encoded string contains a given
+     * @notice Intended to check if a `bytes32`-encoded string contains a given
      * character with UTF-8 character code `utf8CharCode exactly `targetQty`
      * times. Does not support searching for multi-byte characters, only
      * characters with UTF-8 character codes < 0x80.
@@ -43,9 +43,9 @@ library Bytes32Strings {
         uint8 utf8CharCode,
         uint8 targetQty
     ) internal pure returns (bool) {
-        uint8 _occurrences = 0;
+        uint8 _occurrences;
         uint8 i;
-        for (i = 0; i < 32; ) {
+        for (i; i < 32; ) {
             uint8 _charCode = uint8(source[i]);
             // if not a null byte, or a multi-byte UTF-8 character, check match
             if (_charCode != 0 && _charCode < 0x80) {