@artblocks/contracts 1.1.0 → 1.2.0

package/contracts/split/SplitAtomicFactoryV0.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
+pragma solidity 0.8.22;
+
+import {ISplitAtomicV0, Split} from "../interfaces/v0.8.x/ISplitAtomicV0.sol";
+import {ISplitAtomicFactoryV0} from "../interfaces/v0.8.x/ISplitAtomicFactoryV0.sol";
+
+import {Clones} from "@openzeppelin-5.0/contracts/proxy/Clones.sol";
+
+/**
+ * @title SplitAtomicFactoryV0
+ * @author Art Blocks Inc.
+ * @notice Factory contract for creating new split atomic contracts.
+ * @dev This contract is deployed once, and then used to create new split
+ * atomic contracts. The contract may be abandoned once it is no longer needed.
+ * Once abandoned, the contract can no longer be used to create new split
+ * atomic contracts.
+ * The contract is initialized with a required split address and basis points.
+ * All splits must include the required split address and basis points.
+ * The contract is initialized with an implementation contract, which is cloned
+ * when creating new split atomic contracts.
+ */
+contract SplitAtomicFactoryV0 is ISplitAtomicFactoryV0 {
+    // public type
+    bytes32 public constant type_ = "SplitAtomicFactoryV0";
+
+    /**
+     * The implementation contract that is cloned when creating new split
+     * atomic contracts.
+     */
+    address public immutable splitAtomicImplementation;
+
+    // required split address and basis points
+    // @dev make immutable to avoid SLOAD on every createSplit call
+    address public immutable requiredSplitAddress;
+    uint16 public immutable requiredSplitBasisPoints;
+
+    // deployer of the contract is the only one who may abandon the contract
+    address public immutable deployer;
+
+    /**
+     * Indicates whether the contract is abandoned.
+     * Once abandoned, the contract can no longer be used to create new split
+     * atomic contracts.
+     */
+    bool public isAbandoned; // default false
+
+    /**
+     * @notice validates and assigns immutable configuration variables
+     * @param splitAtomicImplementation_ address of the split atomic
+     * implementation contract
+     * @param requiredSplitAddress_ address that must be included in all splits
+     * @param requiredSplitBasisPoints_ basis points that must be included in
+     * all splits, for the required split address. Must be <= 10_000.
+     */
+    constructor(
+        address splitAtomicImplementation_,
+        address requiredSplitAddress_,
+        uint16 requiredSplitBasisPoints_
+    ) {
+        // input validation
+        require(
+            requiredSplitBasisPoints_ <= 10_000,
+            "only reqd split BPS <= 10_000"
+        );
+        splitAtomicImplementation = splitAtomicImplementation_;
+        requiredSplitAddress = requiredSplitAddress_;
+        requiredSplitBasisPoints = requiredSplitBasisPoints_;
+        deployer = msg.sender;
+        // emit event
+        emit Deployed({
+            implementation: splitAtomicImplementation_,
+            type_: type_,
+            requiredSplitAddress: requiredSplitAddress_,
+            requiredSplitBasisPoints: requiredSplitBasisPoints_
+        });
+    }
+
+    /**
+     * @notice Creates a new split atomic contract with the provided `splits`.
+     * @param splits Splits to configure the contract with. Must add up to
+     * 10_000 BPS, and the first split must be the required split; reverts
+     * otherwise.
+     * @return splitAtomic The address of the newly created split atomic
+     * contract. The address is also emitted in the `SplitAtomicCreated` event.
+     */
+    function createSplit(
+        Split[] calldata splits
+    ) external returns (address splitAtomic) {
+        require(!isAbandoned, "factory is abandoned");
+        // validate first split is initial split
+        require(
+            splits[0].recipient == requiredSplitAddress &&
+                splits[0].basisPoints == requiredSplitBasisPoints,
+            "splits[0] must be required split"
+        );
+        // Create the EIP 1167 split atomic contract
+        splitAtomic = Clones.clone({implementation: splitAtomicImplementation});
+        // initialize the new split atomic contract
+        ISplitAtomicV0(splitAtomic).initialize(splits);
+        // emit event
+        emit SplitAtomicCreated(splitAtomic);
+    }
+
+    /**
+     * @notice Abandons the contract, preventing it from being used to create
+     * new split atomic contracts.
+     * Only callable by the deployer, and only once; reverts otherwise.
+     */
+    function abandon() external {
+        require(!isAbandoned, "factory is abandoned");
+        require(msg.sender == deployer, "only deployer may abandon");
+        // set isAbandoned to true
+        isAbandoned = true;
+        // emit event
+        emit Abandoned();
+    }
+}

package/contracts/split/SplitAtomicV0.sol

@@ -0,0 +1,265 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
+pragma solidity 0.8.22;
+
+import {ISplitAtomicV0, Split} from "../interfaces/v0.8.x/ISplitAtomicV0.sol";
+
+import {IERC20} from "@openzeppelin-5.0/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin-5.0/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title SplitAtomicV0
+ * @author Art Blocks Inc.
+ * @notice This contract splits received funds according to the configured
+ * `splits`, which are immutably configured at initialization time.
+ * Each split is defined as a `recipient` address and a `basisPoints` value.
+ * The total of all `basisPoints` values must add up to 10_000 (100%), which
+ * is verified at initialization time. All splits must be non-zero.
+ *
+ * When the contract receives funds, it splits the funds according to the
+ * configured `splits`. The contract can also manually split any funds that
+ * were sent outside of the `receive` function via the `drainETH` function.
+ * Additionally, a `drainERC20` function is provided to split any ERC20 tokens
+ * that were sent to the contract.
+ *
+ * There may be a small amount of funds left behind when splitting funds, due
+ * to integer division rounding down. This is conservatively safe (will always
+ * run a split), but may leave a small amount of funds behind (e.g. a few wei).
+ * The small amount of funds left behind can always be drained later, but
+ * likely never worth the gas.
+ */
+contract SplitAtomicV0 is ISplitAtomicV0 {
+    // simplified, initializable reentrancy guard
+    uint256 private constant _NOT_ENTERED = 1;
+    uint256 private constant _ENTERED = 2;
+    uint256 private constant _NOT_INITIALIZED = 0;
+    uint256 private _status; // initial value: _NOT_INITIALIZED (0)
+
+    // public type
+    bytes32 public constant type_ = "SplitAtomicV0";
+
+    // private array of Splits
+    Split[] private _splits;
+
+    /**
+     * @dev Prevents contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and making it call a
+     * `private` function that does the actual work.
+     * @dev prefer to use modifier here due to wrapped function behavior
+     */
+    modifier nonReentrant() {
+        _nonReentrantBefore();
+        _;
+        _nonReentrantAfter();
+    }
+
+    /**
+     * @notice receive function splits received funds according to the
+     * configured `splits`.
+     * Reverts if contract is not yet initialized.
+     * Non-reentrant function.
+     * @dev This function automatically splits funds when the native token of a
+     * blockchain is sent to the contract. It is important to note that this
+     * function uses an unspecified amount of gas, and therefore sending funds
+     * to this contract via the deprecated `transfer` method is not supported.
+     * @dev This function relies on being non-reentrant for security.
+     */
+    receive() external payable nonReentrant {
+        // split received funds
+        // @dev reverts if not already initialized
+        _splitETH(msg.value);
+    }
+
+    /**
+     * @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 {
+        // initialize reentrancy guard
+        // @dev this reverts if already initialized, preventing this function
+        // from ever being called more than once
+        _reentrancyGuardInit();
+        // validate splits
+        uint256 totalBasisPoints = 0;
+        uint256 splitsLength = splits.length;
+        // @dev splits length implicitly checked to be > 0 via totalBasisPoints
+        // check after loop
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = splits[i];
+            uint256 bps = split.basisPoints;
+            require(bps > 0 && bps <= 10_000, "Invalid basis points");
+            // push the splits to the storage array
+            _splits.push(split);
+            // track total basis points for totals validation after loop
+            // @dev overflow checked automatically in solidity 0.8
+            totalBasisPoints += bps;
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+        require(totalBasisPoints == 10_000, "Invalid total basis points");
+        // emit initialized event
+        emit Initialized(type_);
+    }
+
+    /**
+     * @notice Drains the contract's balance to the configured `splits`.
+     * Reverts if not initialized.
+     * @dev This function is useful for draining the contract's balance to the
+     * configured `splits` in the event that the contract receives funds via
+     * a force-send (e.g. `SELFDESTRUCT` or `SENDALL`) operation.
+     * @dev This function relies on being non-reentrant for security.
+     */
+    function drainETH() external nonReentrant {
+        // split contract balance
+        uint256 balance = address(this).balance;
+        if (balance > 0) {
+            // @dev reverts if not initialized
+            _splitETH(balance);
+        }
+        emit DrainedETH();
+    }
+
+    /**
+     * @notice Drains the contract's balance of an input ERC20 token to the
+     * configured `splits`.
+     * Reverts if not initialized
+     * @dev This function is useful for draining the contract's balance of an
+     * ERC20 token to the configured `splits`. ERC20 tokens are not split upon
+     * receiving (due to transfers not always calling a receive hook),
+     * therefore this function provides critical functionality for this
+     * contract.
+     * @dev This function relies on being non-reentrant for security.
+     * @param ERC20TokenAddress The address of the ERC20 token to split.
+     */
+    function drainERC20(address ERC20TokenAddress) external nonReentrant {
+        // split contract balance of ERC20 token
+        uint256 balance = IERC20(ERC20TokenAddress).balanceOf(address(this));
+        if (balance > 0) {
+            // @dev reverts if not initialized
+            _splitERC20({ERC20TokenAddress: ERC20TokenAddress, value: balance});
+        }
+        emit DrainedERC20(ERC20TokenAddress);
+    }
+
+    /**
+     * @notice Returns the configured `splits`.
+     * @return Split[] memory The configured `splits`.
+     */
+    function getSplits() external view returns (Split[] memory) {
+        return _splits;
+    }
+
+    /**
+     * @notice Splits the input `valueInWei` of ETH to the configured `splits`.
+     * Reverts if any transfers fail. Reverts if called outside of a
+     * non-reentrant function. Reverts if not initialized.
+     * @param valueInWei The amount of ETH to split.
+     */
+    function _splitETH(uint256 valueInWei) internal {
+        // require only called in the context of a non-reentrant function
+        // @dev this provides fault-tolerant behavior for reentrancy guards
+        // @dev this also implicitly verifies contract is initialized
+        // @dev no cover on next line else banch due to fault-tolerant check
+        require(_status == _ENTERED, "only in non-reentrant function");
+        // split funds
+        uint256 splitsLength = _splits.length;
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = _splits[i];
+            // @dev overflow checked automatically in solidity 0.8
+            // @dev integer division rounds down, which is conservatively safe
+            // when splitting funds. Will not run out of funds, but may leave a
+            // small amount behind (e.g. a few wei). Can always be drained
+            // later, but likely never worth the gas.
+            uint256 splitValue = (valueInWei * split.basisPoints) / 10_000;
+            // send funds
+            (bool success, ) = split.recipient.call{value: splitValue}("");
+            require(success, "Payment failed");
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Splits the input `value` of ERC20 token at `ERC20TokenAddress`
+     * to the configured `splits`.
+     * Reverts if any transfers fail. Reverts if called outside of a
+     * non-reentrant function. Reverts if not initialized.
+     * @param ERC20TokenAddress The address of the ERC20 token to split.
+     * @param value The amount of the ERC20 token to split.
+     */
+    function _splitERC20(address ERC20TokenAddress, uint256 value) internal {
+        // require only called in the context of a non-reentrant function
+        // @dev this provides fault-tolerant behavior for reentrancy guards
+        // @dev this also implicitly verifies contract is initialized
+        // @dev no cover on next line else banch due to fault-tolerant check
+        require(_status == _ENTERED, "only in non-reentrant function");
+        // split funds
+        uint256 splitsLength = _splits.length;
+        IERC20 token = IERC20(ERC20TokenAddress);
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = _splits[i];
+            // @dev overflow checked automatically in solidity 0.8
+            // @dev integer division rounds down, which is conservatively safe
+            // when splitting funds. Will not run out of funds, but may leave a
+            // small amount behind (e.g. a few wei). Can always be drained
+            // later, but likely never worth the gas.
+            uint256 splitValue = (value * split.basisPoints) / 10_000;
+            // transfer ERC20 tokens
+            // @dev use SafeERC20 to only revert if ERC20 transfer returns
+            // false, not if it returns nothing (which is the behavior of some
+            // ERC20 tokens, and we don't want to forever lock those tokens)
+            SafeERC20.safeTransfer({
+                token: token,
+                to: split.recipient,
+                value: splitValue
+            });
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Initializes the reentrancy guard. This function will revert if
+     * the contract is already initialized.
+     */
+    function _reentrancyGuardInit() private {
+        // require not already initialized
+        require(_status == _NOT_INITIALIZED, "Already initialized");
+        // set status to not entered
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @notice Sets the reentrancy guard status to `_ENTERED`.
+     * Reverts if the guard is already entered.
+     */
+    function _nonReentrantBefore() private {
+        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
+        // Any calls to nonReentrant after this point will fail
+        _status = _ENTERED;
+    }
+
+    /**
+     * @notice Sets the reentrancy guard status to `_NOT_ENTERED`, allowing
+     * calls to `nonReentrant` functions again.
+     */
+    function _nonReentrantAfter() private {
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _status = _NOT_ENTERED;
+    }
+}

package/contracts/split/split-provider/SplitProviderV0.sol

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {ISplitProviderV0} from "../../interfaces/v0.8.x/ISplitProviderV0.sol";
+import {ISplitFactoryV2} from "../../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+
+import {ERC165} from "@openzeppelin-5.0/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title SplitProviderV0
+ * @author Art Blocks Inc.
+ * @notice Split Provider to get or create immutable split contracts.
+ * This version of SplitProvider integrates with 0xSplits v2 to provide
+ * immutable split contracts.
+ * This contract is permissionless and does not have an owner. It is intended
+ * to be used by other contracts to create immutable split contracts, while
+ * adding a layer of abstraction to reduce the complexity of interacting with
+ * 0xSplits v2 directly, as well as to enable future migration paths to new
+ * upgrades.
+ * ----------------------------------------------------------------------------
+ * All split contracts will be created with the following properties:
+ * - The split contract will be immutable.
+ * - The split contract will be created with the provided split parameters.
+ * - The split contract includes zero distribution incentive.
+ * - The split contract will be created at a deterministic address, given the
+ *   input split parameters and contract calling this contract (as well as the
+ *   third party 0xSplits SplitFactoryV2 address).
+ */
+contract SplitProviderV0 is ISplitProviderV0, ERC165 {
+    bytes32 private constant _TYPE = "SplitProviderV0";
+
+    // 0xSplits SplitFactoryV2 address immutably configured on this contract
+    ISplitFactoryV2 private immutable _splitFactoryV2;
+
+    /**
+     * @notice Construct a new SplitProviderV0 contract.
+     * @param splitFactoryV2Address The immutable 0xSplits SplitFactoryV2 address.
+     */
+    constructor(ISplitFactoryV2 splitFactoryV2Address) {
+        _splitFactoryV2 = ISplitFactoryV2(splitFactoryV2Address);
+    }
+
+    /**
+     * @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).
+     * Returns null address if no royalties are due.
+     * @dev Uses the 0xSplits v2 implementation to create a splitter contract
+     * @dev Intentionally unpermissioned; no owner required; all created splits
+     * are immutable and deterministic
+     * @param splitInputs The split input parameters.
+     * @return splitter The newly created splitter contract address.
+     */
+    function getOrCreateSplitter(
+        SplitInputs calldata splitInputs
+    ) external override returns (address) {
+        // edge case: no royalties due; return zero address
+        if (
+            splitInputs.artistTotalRoyaltyPercentage +
+                splitInputs.renderProviderSecondarySalesBPS +
+                splitInputs.platformProviderSecondarySalesBPS ==
+            0
+        ) {
+            return address(0);
+        }
+        // create Split struct from SplitInputs
+        ISplitFactoryV2.Split memory splitParams = _getSplitParams({
+            splitInputs: splitInputs
+        });
+        // use sender as salt to ensure unique splitters across contracts/partners for accounting
+        bytes32 salt = bytes32(bytes20(msg.sender));
+        // determine if splitter already exists
+        (address splitter, bool exists) = _splitFactoryV2.isDeployed({
+            _splitParams: splitParams,
+            _owner: address(0), // no owner, immutable,
+            _salt: salt
+        });
+        if (!exists) {
+            // create new splitter contract
+            // @dev no need to re-assign returned address; isDeployed already populated it
+            _splitFactoryV2.createSplitDeterministic({
+                _splitParams: splitParams,
+                _owner: address(0), // no owner, immutable
+                _creator: address(this),
+                _salt: salt
+            });
+
+            // emit event for new splitter creation
+            emit SplitterCreated({splitter: splitter});
+        }
+
+        return splitter;
+    }
+
+    /**
+     * @notice Get the immutable 0xSplits SplitFactoryV2 address used by this SplitProviderV0.
+     * @return splitFactoryV2 The 0xSplits SplitFactoryV2 address.
+     */
+    function getSplitFactoryV2() external view returns (ISplitFactoryV2) {
+        return _splitFactoryV2;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override returns (bool) {
+        // broadcast support of the getOrCreateSplitter function
+        // @dev intentionally only including getOrCreateSplitter, as that is the only function
+        // that is intended to be used for on-chain integration (type_ is for indexing and introspection only)
+        return
+            interfaceId == this.getOrCreateSplitter.selector ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @notice Indicates the type of the contract, e.g. `SplitProviderV0`.
+     * @return type_ The type of the contract.
+     */
+    function type_() external pure returns (bytes32) {
+        return _TYPE;
+    }
+
+    /**
+     * Converts the split inputs to the split parameters used by 0xSplits V2.
+     * This function assumes there is at least one party with a non-zero allocation,
+     * and should not be called if there are no royalties due.
+     * @param splitInputs The split input parameters.
+     * @return splitParams The split parameters in the form used by 0xSplits V2.
+     */
+    function _getSplitParams(
+        SplitInputs calldata splitInputs
+    ) private pure returns (ISplitFactoryV2.Split memory splitParams) {
+        // define allocations in BPS to avoid any rounding errors
+        uint256 artistAndAdditionalRoyaltyPercentage = splitInputs
+            .artistTotalRoyaltyPercentage;
+        uint256 artistAndAdditionalRoyaltyBPS = 100 *
+            artistAndAdditionalRoyaltyPercentage;
+        // load render provider royalty BPS
+        uint256 renderProviderRoyaltyBPS = splitInputs
+            .renderProviderSecondarySalesBPS;
+        // load platform provider royalty BPS
+        uint256 platformProviderRoyaltyBPS = splitInputs
+            .platformProviderSecondarySalesBPS;
+
+        bool artistNonZero = artistAndAdditionalRoyaltyPercentage > 0 &&
+            splitInputs.additionalPayeePercentage < 100;
+        bool additionalPayeeNonZero = artistAndAdditionalRoyaltyPercentage >
+            0 &&
+            splitInputs.additionalPayeePercentage > 0;
+        bool renderNonZero = renderProviderRoyaltyBPS > 0;
+        bool platformNonZero = platformProviderRoyaltyBPS > 0;
+
+        // allocate memory for splitParams arrays
+        uint256 partyLength = (artistNonZero ? 1 : 0) +
+            (additionalPayeeNonZero ? 1 : 0) +
+            (renderNonZero ? 1 : 0) +
+            (platformNonZero ? 1 : 0);
+        splitParams.recipients = new address[](partyLength);
+        splitParams.allocations = new uint256[](partyLength);
+        splitParams.totalAllocation =
+            artistAndAdditionalRoyaltyBPS +
+            renderProviderRoyaltyBPS +
+            platformProviderRoyaltyBPS;
+
+        // populate each party's split
+        uint256 currentIndex = 0;
+        if (artistNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs.artist;
+            // @dev percent * 100 converts to BPS
+            splitParams.allocations[currentIndex++] =
+                artistAndAdditionalRoyaltyPercentage *
+                (100 - splitInputs.additionalPayeePercentage);
+        }
+        if (additionalPayeeNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs.additionalPayee;
+            // @dev percent * 100 converts to BPS
+            splitParams.allocations[currentIndex++] =
+                artistAndAdditionalRoyaltyPercentage *
+                splitInputs.additionalPayeePercentage;
+        }
+        if (renderNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs
+                .renderProviderSecondarySalesAddress;
+            splitParams.allocations[currentIndex++] = renderProviderRoyaltyBPS;
+        }
+        if (platformNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs
+                .platformProviderSecondarySalesAddress;
+            splitParams.allocations[
+                currentIndex // no need to increment, last element
+            ] = platformProviderRoyaltyBPS;
+        }
+
+        // @dev leave distribution incentive as zero on all splits
+    }
+}