@artblocks/contracts 1.1.0 → 1.2.0

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

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import {Split} from "./ISplitAtomicV0.sol";
+
+interface ISplitAtomicFactoryV0 {
+    /**
+     * @notice This contract was deployed.
+     * @param implementation address with the implementation of the contract
+     * @param type_ type of this contract
+     * @param requiredSplitAddress address that must be included in all splits
+     * @param requiredSplitBasisPoints basis points that must be included in
+     * all splits
+     */
+    event Deployed(
+        address indexed implementation,
+        bytes32 indexed type_,
+        address requiredSplitAddress,
+        uint16 requiredSplitBasisPoints
+    );
+    /**
+     * @notice New split atomic contract was created.
+     * @param splitAtomic address of the newly created split atomic contract
+     */
+    event SplitAtomicCreated(address indexed splitAtomic);
+    /**
+     * @notice This contract was abandoned and no longer can be used to create
+     * new split atomic contracts.
+     */
+    event Abandoned();
+
+    /**
+     * @notice Initializes the contract with the provided `splits`.
+     * Only callable once.
+     * @param splits Splits to configure the contract with. Must add up to
+     * 10_000 BPS.
+     * @return splitAtomic The address of the newly created split atomic
+     * contract
+     */
+    function createSplit(
+        Split[] calldata splits
+    ) external returns (address splitAtomic);
+
+    /**
+     * @notice The implementation contract that is cloned when creating new
+     * split atomic contracts.
+     */
+    function splitAtomicImplementation() external view returns (address);
+
+    /**
+     * @notice The address that must be included in all splits.
+     */
+    function requiredSplitAddress() external view returns (address);
+
+    /**
+     * @notice The basis points that must be included in all splits, for the
+     * required split address.
+     */
+    function requiredSplitBasisPoints() external view returns (uint16);
+
+    /**
+     * @notice The deployer of the contract.
+     */
+    function deployer() external view returns (address);
+
+    /**
+     * @notice Indicates whether the contract is abandoned.
+     * Once abandoned, the contract can no longer be used to create new split
+     * atomic contracts.
+     * @return bool True if the contract is abandoned, false otherwise.
+     */
+    function isAbandoned() external view returns (bool);
+
+    /**
+     * @notice Indicates the type of the contract, e.g. `SplitAtomicFactoryV0`.
+     * @return type_ The type of the contract.
+     */
+    function type_() external pure returns (bytes32);
+}

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

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Struct representing a split.
+ * @param recipient The address to send funds to.
+ * @param basisPoints The basis points to allocate to recipient (1-10_000).
+ */
+struct Split {
+    // address to send funds to
+    address payable recipient;
+    // basis points to allocate to recipient (1-10_000)
+    uint16 basisPoints;
+}
+
+interface ISplitAtomicV0 {
+    /**
+     * @notice Indicates that the contract has been initialized.
+     * @param type_ The type of the contract.
+     */
+    event Initialized(bytes32 type_);
+
+    /**
+     * @notice Indicates that the contract's balance manually was drained of
+     * ETH.
+     */
+    event DrainedETH();
+
+    /**
+     * @notice Indicates that the contract's balance manually was drained of
+     * ERC20 token at address `ERC20TokenAddress`.
+     * @param ERC20TokenAddress The address of the ERC20 token that was
+     * drained.
+     */
+    event DrainedERC20(address ERC20TokenAddress);
+
+    /**
+     * @notice Initializes the contract with the provided `splits`.
+     * This function should be called atomically, immediately after deployment.
+     * Only callable once.
+     * @param splits Splits to configure the contract with. Must add up to
+     * 10_000 BPS.
+     */
+    function initialize(Split[] calldata splits) external;
+
+    /**
+     * @notice Drains the contract's ETH balance to the configured `splits`.
+     * Reverts if not initialized.
+     */
+    function drainETH() external;
+
+    /**
+     * @notice Drains the contract's balance of an input ERC20 token to the
+     * configured `splits`. Reverts if not initialized.
+     * @param ERC20TokenAddress The address of the ERC20 token to split.
+     */
+    function drainERC20(address ERC20TokenAddress) external;
+
+    /**
+     * @notice Returns the configured `splits`.
+     * @return Split[] memory The configured `splits`.
+     */
+    function getSplits() external view returns (Split[] memory);
+
+    /**
+     * @notice Indicates the type of the contract, e.g. `SplitAtomicV0`.
+     * @return type_ The type of the contract.
+     */
+    function type_() external pure returns (bytes32);
+}

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

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import {ISplitFactoryV2} from "./integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+
+interface ISplitProviderV0 {
+    /**
+     * @notice SplitInputs struct defines the inputs for requested splitters.
+     * It is defined in a way easily communicated from the Art Blocks GenArt721V3 contract,
+     * to allow for easy integration and minimal additional bytecode in the GenArt721V3 contract.
+     */
+    struct SplitInputs {
+        address platformProviderSecondarySalesAddress;
+        uint16 platformProviderSecondarySalesBPS;
+        address renderProviderSecondarySalesAddress;
+        uint16 renderProviderSecondarySalesBPS;
+        uint8 artistTotalRoyaltyPercentage;
+        address artist;
+        address additionalPayee;
+        uint8 additionalPayeePercentage;
+    }
+
+    /**
+     * @notice Emitted when a new splitter contract is created.
+     * @param splitter address of the splitter contract
+     */
+    event SplitterCreated(address indexed splitter);
+
+    /**
+     * @notice Gets or creates an immutable splitter contract at a deterministic address.
+     * Splits in the splitter contract are determined by the input split parameters,
+     * so we can safely create the splitter contract at a deterministic address (or use
+     * the existing splitter contract if it already exists at that address).
+     * @dev Uses the 0xSplits v2 implementation to create a splitter contract
+     * @param splitInputs The split input parameters.
+     * @return splitter The newly created splitter contract address.
+     */
+    function getOrCreateSplitter(
+        SplitInputs calldata splitInputs
+    ) external returns (address);
+
+    /**
+     * @notice Indicates the type of the contract, e.g. `SplitProviderV0`.
+     * @return type_ The type of the contract.
+     */
+    function type_() external pure returns (bytes32);
+}

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

@@ -21,10 +21,8 @@ library ABHelpers {
         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;
     }
 
     /**
@@ -39,6 +37,22 @@ library ABHelpers {
         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;
+        }
+    }
+
     /**
      * @notice Function to convert project id and token number to token id.
      * @param projectId The id of the project.

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