@artblocks/contracts 1.0.4 → 1.2.0

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

@@ -14,42 +14,56 @@ library ABHelpers {
     uint256 constant ONE_MILLION = 1_000_000;
 
     /**
-     * Convert token id to project id.
-     * @param _tokenId The id of the token.
+     * @notice Function to convert token id to project id.
+     * @param tokenId The id of the token.
      */
     function tokenIdToProjectId(
-        uint256 _tokenId
+        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;
     }
 
     /**
-     * Convert token id to token number.
-     * @param _tokenId The id of the token.
+     * @notice Function to convert token id to token number.
+     * @param tokenId The id of the token.
      */
     function tokenIdToTokenNumber(
-        uint256 _tokenId
+        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;
+        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;
+        }
     }
 
     /**
-     * Convert project id and token number to token id.
-     * @param _projectId The id of the project.
-     * @param _tokenNumber The token number.
+     * @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
+        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;
+        return (projectId * ONE_MILLION) + tokenNumber;
     }
 }

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

@@ -3,8 +3,8 @@
 
 pragma solidity ^0.8.0;
 
-import "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
-import "../../interfaces/v0.8.x/IMinterFilterV1.sol";
+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
@@ -16,111 +16,110 @@ import "../../interfaces/v0.8.x/IMinterFilterV1.sol";
 
 library AuthLib {
     /**
-     * function to restrict access to only AdminACL allowed calls, where
+     * @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,
+     * @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
+     * @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
+        address minterFilterAddress,
+        address sender,
+        address contract_,
+        bytes4 selector
     ) internal {
         require(
             _minterFilterAdminACLAllowed({
-                _minterFilterAddress: _minterFilterAddress,
-                _sender: _sender,
-                _contract: _contract,
-                _selector: _selector
+                minterFilterAddress: minterFilterAddress,
+                sender: sender,
+                contract_: contract_,
+                selector: selector
             }),
             "Only MinterFilter AdminACL"
         );
     }
 
     /**
-     * Function to restrict access to only AdminACL allowed calls, where
-     * AdminACL is the admin of a core contract at `_coreContract`.
+     * @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
+     * @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
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
     ) internal {
         require(
             _coreAdminACLAllowed({
-                _coreContract: _coreContract,
-                _sender: _sender,
-                _contract: _contract,
-                _selector: _selector
+                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`.
-     * Requirements: `msg.sender` must be the artist associated with
-     * `_projectId` on `_coreContract`.
-     * @param _projectId The ID of the project being checked.
-     * @param _coreContract The address of the GenArt721CoreContractV3_Base
+     * @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.
+     * @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
+        uint256 projectId,
+        address coreContract,
+        address sender
     ) internal view {
         require(
             _senderIsArtist({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _sender: _sender
+                projectId: projectId,
+                coreContract: coreContract,
+                sender: sender
             }),
             "Only Artist"
         );
     }
 
     /**
-     * function to restrict access to only the artist of a project, or AdminACL
+     * @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
+     * `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
+        uint256 projectId,
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
     ) internal {
         require(
             _senderIsArtist({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _sender: _sender
+                projectId: projectId,
+                coreContract: coreContract,
+                sender: sender
             }) ||
                 _coreAdminACLAllowed({
-                    _coreContract: _coreContract,
-                    _sender: _sender,
-                    _contract: _contract,
-                    _selector: _selector
+                    coreContract: coreContract,
+                    sender: sender,
+                    contract_: contract_,
+                    selector: selector
                 }),
             "Only Artist or Core Admin ACL"
         );
@@ -131,67 +130,67 @@ library AuthLib {
     // ------------------------------------------------------------------------
 
     /**
-     * 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.
+     * @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
+     * @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
+        address minterFilterAddress,
+        address sender,
+        address contract_,
+        bytes4 selector
     ) private returns (bool) {
         return
-            IMinterFilterV1(_minterFilterAddress).adminACLAllowed({
-                _sender: _sender,
-                _contract: _contract,
-                _selector: _selector
+            IMinterFilterV1(minterFilterAddress).adminACLAllowed({
+                sender: sender,
+                contract_: contract_,
+                selector: selector
             });
     }
 
     /**
-     * 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
+     * @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
+        address coreContract,
+        address sender,
+        address contract_,
+        bytes4 selector
     ) private returns (bool) {
         return
-            IGenArt721CoreContractV3_Base(_coreContract).adminACLAllowed({
-                _sender: _sender,
-                _contract: _contract,
-                _selector: _selector
+            IGenArt721CoreContractV3_Base(coreContract).adminACLAllowed({
+                _sender: sender,
+                _contract: contract_,
+                _selector: selector
             });
     }
 
     /**
-     * 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
+     * @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
+        uint256 projectId,
+        address coreContract,
+        address sender
     ) private view returns (bool senderIsArtist) {
         return
-            _sender ==
-            IGenArt721CoreContractV3_Base(_coreContract)
-                .projectIdToArtistAddress(_projectId);
+            sender ==
+            IGenArt721CoreContractV3_Base(coreContract)
+                .projectIdToArtistAddress(projectId);
     }
 }

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