@artblocks/contracts 1.1.0 → 1.2.1

package/contracts/mock/MockFileStore.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {IScriptyContractStorage} from "scripty.sol/contracts/scripty/interfaces/IScriptyContractStorage.sol";
+
+contract MockFileStore is IScriptyContractStorage {
+    string constant GUNZIP_SCRIPT_NAME = "gunzipScripts-0.0.1.js";
+
+    function getContent(
+        string calldata name,
+        bytes memory
+    ) external pure returns (bytes memory script) {
+        if (
+            keccak256(abi.encodePacked(name)) ==
+            keccak256(abi.encodePacked(GUNZIP_SCRIPT_NAME))
+        ) {
+            return
+                "InVzZSBzdHJpY3QiOygoKT0+e3ZhciB2PVVpbnQ4QXJyYXksQT1VaW50MTZBcnJheSxfPVVpbnQzMkFycmF5LHJyPW5ldyB2KFswLDAsMCwwLDAsMCwwLDAsMSwxLDEsMSwyLDIsMiwyLDMsMywzLDMsNCw0LDQsNCw1LDUsNSw1LDAsMCwwLDBdKSxucj1uZXcgdihbMCwwLDAsMCwxLDEsMiwyLDMsMyw0LDQsNSw1LDYsNiw3LDcsOCw4LDksOSwxMCwxMCwxMSwxMSwxMiwxMiwxMywxMywwLDBdKSxscj1uZXcgdihbMTYsMTcsMTgsMCw4LDcsOSw2LDEwLDUsMTEsNCwxMiwzLDEzLDIsMTQsMSwxNV0pLHRyPWZ1bmN0aW9uKHIsbil7Zm9yKHZhciB0PW5ldyBBKDMxKSxlPTA7ZTwzMTsrK2UpdFtlXT1uKz0xPDxyW2UtMV07Zm9yKHZhciBhPW5ldyBfKHRbMzBdKSxlPTE7ZTwzMDsrK2UpZm9yKHZhciB1PXRbZV07dTx0W2UrMV07Kyt1KWFbdV09dS10W2VdPDw1fGU7cmV0dXJuW3QsYV19LGVyPXRyKHJyLDIpLGlyPWVyWzBdLGNyPWVyWzFdO2lyWzI4XT0yNTgsY3JbMjU4XT0yODt2YXIgYXI9dHIobnIsMCkscHI9YXJbMF0sVXI9YXJbMV0scT1uZXcgQSgzMjc2OCk7Zm9yKG89MDtvPDMyNzY4OysrbyltPShvJjQzNjkwKT4+PjF8KG8mMjE4NDUpPDwxLG09KG0mNTI0MjgpPj4+MnwobSYxMzEwNyk8PDIsbT0obSY2MTY4MCk+Pj40fChtJjM4NTUpPDw0LHFbb109KChtJjY1MjgwKT4+Pjh8KG0mMjU1KTw8OCk+Pj4xO3ZhciBtLG8sRD1mdW5jdGlvbihyLG4sdCl7Zm9yKHZhciBlPXIubGVuZ3RoLGE9MCx1PW5ldyBBKG4pO2E8ZTsrK2EpclthXSYmKyt1W3JbYV0tMV07dmFyIGc9bmV3IEEobik7Zm9yKGE9MDthPG47KythKWdbYV09Z1thLTFdK3VbYS0xXTw8MTt2YXIgcztpZih0KXtzPW5ldyBBKDE8PG4pO3ZhciBpPTE1LW47Zm9yKGE9MDthPGU7KythKWlmKHJbYV0pZm9yKHZhciBmPWE8PDR8clthXSxoPW4tclthXSxsPWdbclthXS0xXSsrPDxoLHc9bHwoMTw8aCktMTtsPD13OysrbClzW3FbbF0+Pj5pXT1mfWVsc2UgZm9yKHM9bmV3IEEoZSksYT0wO2E8ZTsrK2EpclthXSYmKHNbYV09cVtnW3JbYV0tMV0rK10+Pj4xNS1yW2FdKTtyZXR1cm4gc30sRT1uZXcgdigyODgpO2ZvcihvPTA7bzwxNDQ7KytvKUVbb109ODt2YXIgbztmb3Iobz0xNDQ7bzwyNTY7KytvKUVbb109OTt2YXIgbztmb3Iobz0yNTY7bzwyODA7KytvKUVbb109Nzt2YXIgbztmb3Iobz0yODA7bzwyODg7KytvKUVbb109ODt2YXIgbyxvcj1uZXcgdigzMik7Zm9yKG89MDtvPDMyOysrbylvcltvXT01O3ZhciBvO3ZhciBncj1EKEUsOSwxKTt2YXIgeXI9RChvciw1LDEpLFI9ZnVuY3Rpb24ocil7Zm9yKHZhciBuPXJbMF0sdD0xO3Q8ci5sZW5ndGg7Kyt0KXJbdF0+biYmKG49clt0XSk7cmV0dXJuIG59LHA9ZnVuY3Rpb24ocixuLHQpe3ZhciBlPW4vOHwwO3JldHVybihyW2VdfHJbZSsxXTw8OCk+PihuJjcpJnR9LCQ9ZnVuY3Rpb24ocixuKXt2YXIgdD1uLzh8MDtyZXR1cm4oclt0XXxyW3QrMV08PDh8clt0KzJdPDwxNik+PihuJjcpfSx3cj1mdW5jdGlvbihyKXtyZXR1cm4ocis3KS84fDB9LG1yPWZ1bmN0aW9uKHIsbix0KXsobj09bnVsbHx8bjwwKSYmKG49MCksKHQ9PW51bGx8fHQ+ci5sZW5ndGgpJiYodD1yLmxlbmd0aCk7dmFyIGU9bmV3KHIuQllURVNfUEVSX0VMRU1FTlQ9PTI/QTpyLkJZVEVTX1BFUl9FTEVNRU5UPT00P186dikodC1uKTtyZXR1cm4gZS5zZXQoci5zdWJhcnJheShuLHQpKSxlfTt2YXIgeHI9WyJ1bmV4cGVjdGVkIEVPRiIsImludmFsaWQgYmxvY2sgdHlwZSIsImludmFsaWQgbGVuZ3RoL2xpdGVyYWwiLCJpbnZhbGlkIGRpc3RhbmNlIiwic3RyZWFtIGZpbmlzaGVkIiwibm8gc3RyZWFtIGhhbmRsZXIiLCwibm8gY2FsbGJhY2siLCJpbnZhbGlkIFVURi04IGRhdGEiLCJleHRyYSBmaWVsZCB0b28gbG9uZyIsImRhdGUgbm90IGluIHJhbmdlIDE5ODAtMjA5OSIsImZpbGVuYW1lIHRvbyBsb25nIiwic3RyZWFtIGZpbmlzaGluZyIsImludmFsaWQgemlwIGRhdGEiXSx4PWZ1bmN0aW9uKHIsbix0KXt2YXIgZT1uZXcgRXJyb3Iobnx8eHJbcl0pO2lmKGUuY29kZT1yLEVycm9yLmNhcHR1cmVTdGFja1RyYWNlJiZFcnJvci5jYXB0dXJlU3RhY2tUcmFjZShlLHgpLCF0KXRocm93IGU7cmV0dXJuIGV9LHpyPWZ1bmN0aW9uKHIsbix0KXt2YXIgZT1yLmxlbmd0aDtpZighZXx8dCYmdC5mJiYhdC5sKXJldHVybiBufHxuZXcgdigwKTt2YXIgYT0hbnx8dCx1PSF0fHx0Lmk7dHx8KHQ9e30pLG58fChuPW5ldyB2KGUqMykpO3ZhciBnPWZ1bmN0aW9uKFYpe3ZhciBYPW4ubGVuZ3RoO2lmKFY+WCl7dmFyIGI9bmV3IHYoTWF0aC5tYXgoWCoyLFYpKTtiLnNldChuKSxuPWJ9fSxzPXQuZnx8MCxpPXQucHx8MCxmPXQuYnx8MCxoPXQubCxsPXQuZCx3PXQubSxUPXQubixJPWUqODtkb3tpZighaCl7cz1wKHIsaSwxKTt2YXIgQj1wKHIsaSsxLDMpO2lmKGkrPTMsQilpZihCPT0xKWg9Z3IsbD15cix3PTksVD01O2Vsc2UgaWYoQj09Mil7dmFyIEc9cChyLGksMzEpKzI1NyxZPXAocixpKzEwLDE1KSs0LFc9RytwKHIsaSs1LDMxKSsxO2krPTE0O2Zvcih2YXIgQz1uZXcgdihXKSxPPW5ldyB2KDE5KSxjPTA7YzxZOysrYylPW2xyW2NdXT1wKHIsaStjKjMsNyk7aSs9WSozO2Zvcih2YXIgaj1SKE8pLHNyPSgxPDxqKS0xLHVyPUQoTyxqLDEpLGM9MDtjPFc7KXt2YXIgZD11cltwKHIsaSxzcildO2krPWQmMTU7dmFyIHk9ZD4+PjQ7aWYoeTwxNilDW2MrK109eTtlbHNle3ZhciBTPTAsRj0wO2Zvcih5PT0xNj8oRj0zK3AocixpLDMpLGkrPTIsUz1DW2MtMV0pOnk9PTE3PyhGPTMrcChyLGksNyksaSs9Myk6eT09MTgmJihGPTExK3AocixpLDEyNyksaSs9Nyk7Ri0tOylDW2MrK109U319dmFyIEo9Qy5zdWJhcnJheSgwLEcpLHo9Qy5zdWJhcnJheShHKTt3PVIoSiksVD1SKHopLGg9RChKLHcsMSksbD1EKHosVCwxKX1lbHNlIHgoMSk7ZWxzZXt2YXIgeT13cihpKSs0LFo9clt5LTRdfHJbeS0zXTw8OCxrPXkrWjtpZihrPmUpe3UmJngoMCk7YnJlYWt9YSYmZyhmK1opLG4uc2V0KHIuc3ViYXJyYXkoeSxrKSxmKSx0LmI9Zis9Wix0LnA9aT1rKjgsdC5mPXM7Y29udGludWV9aWYoaT5JKXt1JiZ4KDApO2JyZWFrfX1hJiZnKGYrMTMxMDcyKTtmb3IodmFyIHZyPSgxPDx3KS0xLGhyPSgxPDxUKS0xLEw9aTs7TD1pKXt2YXIgUz1oWyQocixpKSZ2cl0sTT1TPj4+NDtpZihpKz1TJjE1LGk+SSl7dSYmeCgwKTticmVha31pZihTfHx4KDIpLE08MjU2KW5bZisrXT1NO2Vsc2UgaWYoTT09MjU2KXtMPWksaD1udWxsO2JyZWFrfWVsc2V7dmFyIEs9TS0yNTQ7aWYoTT4yNjQpe3ZhciBjPU0tMjU3LFU9cnJbY107Sz1wKHIsaSwoMTw8VSktMSkraXJbY10saSs9VX12YXIgUD1sWyQocixpKSZocl0sTj1QPj4+NDtQfHx4KDMpLGkrPVAmMTU7dmFyIHo9cHJbTl07aWYoTj4zKXt2YXIgVT1ucltOXTt6Kz0kKHIsaSkmKDE8PFUpLTEsaSs9VX1pZihpPkkpe3UmJngoMCk7YnJlYWt9YSYmZyhmKzEzMTA3Mik7Zm9yKHZhciBRPWYrSztmPFE7Zis9NCluW2ZdPW5bZi16XSxuW2YrMV09bltmKzEtel0sbltmKzJdPW5bZisyLXpdLG5bZiszXT1uW2YrMy16XTtmPVF9fXQubD1oLHQucD1MLHQuYj1mLHQuZj1zLGgmJihzPTEsdC5tPXcsdC5kPWwsdC5uPVQpfXdoaWxlKCFzKTtyZXR1cm4gZj09bi5sZW5ndGg/bjptcihuLDAsZil9O3ZhciBBcj1uZXcgdigwKTt2YXIgU3I9ZnVuY3Rpb24ocil7KHJbMF0hPTMxfHxyWzFdIT0xMzl8fHJbMl0hPTgpJiZ4KDYsImludmFsaWQgZ3ppcCBkYXRhIik7dmFyIG49clszXSx0PTEwO24mNCYmKHQrPXJbMTBdfChyWzExXTw8OCkrMik7Zm9yKHZhciBlPShuPj4zJjEpKyhuPj40JjEpO2U+MDtlLT0hclt0KytdKTtyZXR1cm4gdCsobiYyKX0sTXI9ZnVuY3Rpb24ocil7dmFyIG49ci5sZW5ndGg7cmV0dXJuKHJbbi00XXxyW24tM108PDh8cltuLTJdPDwxNnxyW24tMV08PDI0KT4+PjB9O2Z1bmN0aW9uIEgocixuKXtyZXR1cm4genIoci5zdWJhcnJheShTcihyKSwtOCksbnx8bmV3IHYoTXIocikpKX12YXIgVHI9dHlwZW9mIFRleHREZWNvZGVyPCJ1IiYmbmV3IFRleHREZWNvZGVyLENyPTA7dHJ5e1RyLmRlY29kZShBcix7c3RyZWFtOiEwfSksQ3I9MX1jYXRjaHt9dmFyIGZyPSgpPT57dmFyIG47bGV0IHI9ZG9jdW1lbnQucXVlcnlTZWxlY3RvckFsbCgnc2NyaXB0W3R5cGU9InRleHQvamF2YXNjcmlwdCtnemlwIl1bc3JjXScpO2ZvcihsZXQgdCBvZiByKXRyeXtsZXQgZT10LnNyYy5tYXRjaCgvXmRhdGE6KC4qPykoPzo7KGJhc2U2NCkpPywoLiopJC8pO2lmKCFlKWNvbnRpbnVlO2xldFthLHUsZyxzXT1lLGk9VWludDhBcnJheS5mcm9tKGc/YXRvYihzKTpkZWNvZGVVUklDb21wb25lbnQocyksdz0+dy5jaGFyQ29kZUF0KDApKSxoPW5ldyBUZXh0RGVjb2RlcigpLmRlY29kZShIKGkpKSxsPWRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNjcmlwdCIpO2wudGV4dENvbnRlbnQ9aCwobj10LnBhcmVudE5vZGUpPT1udWxsfHxuLnJlcGxhY2VDaGlsZChsLHQpfWNhdGNoKGUpe2NvbnNvbGUuZXJyb3IoIkNvdWxkIG5vdCBndW56aXAgc2NyaXB0Iix0LGUpfX07ZnIoKTt3aW5kb3cuZ3VuemlwU3luYz1IO3dpbmRvdy5ndW56aXBTY3JpcHRzPWZyO30pKCk7";
+        }
+        return abi.encodePacked(name);
+    }
+}

package/contracts/mock/ReentrancyGenArt721MinterMock.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/IGenArt721Minter_PBAB.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyGenArt721MinterMock {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    uint256 public currentPriceToPay;
+    address public currencyAddress;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(
+        uint256 _qtyToPurchase,
+        address _minterContractAddress,
+        uint256 _projectId,
+        uint256 _priceToPay,
+        address _currencyAddress
+    ) external payable {
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentPriceToPay = _priceToPay;
+        currencyAddress = _currencyAddress;
+        IGenArt721Minter_PBAB(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _priceToPay, _currencyAddress);
+    }
+
+    // receiver is called when minter sends refunded Ether to this contract.
+    receive() external payable {
+        // decrement num to be purchased
+        currentQtyToPurchase--;
+        if (currentQtyToPurchase > 0) {
+            // purchase again!
+            IGenArt721Minter_PBAB(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, currentPriceToPay, currencyAddress);
+        }
+    }
+}

package/contracts/mock/ReentrancySplitterMocks.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/ISplitAtomicV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancySplitterSendETHMock {
+    address public currentSplitterAddress;
+    bool public haveReentered;
+
+    receive() external payable {
+        // only re-enter once to prevent infinite loop
+        if (haveReentered) {
+            return;
+        }
+        // update state
+        haveReentered = true;
+        // re-enter via sending ETH to splitter's receive function
+        (bool success, ) = currentSplitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+        // reset state
+        haveReentered = false;
+    }
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(address splitterAddress) external payable {
+        currentSplitterAddress = splitterAddress;
+        (bool success, ) = splitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+    }
+}
+
+contract ReentrancySplitterDrainETHMock {
+    address public currentSplitterAddress;
+    bool public haveReentered;
+
+    receive() external payable {
+        // only re-enter once to prevent infinite loop
+        if (haveReentered) {
+            return;
+        }
+        // update state
+        haveReentered = true;
+        // re-enter via calling splitter's drainETH function
+        ISplitAtomicV0(currentSplitterAddress).drainETH();
+        // reset state
+        haveReentered = false;
+    }
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(address splitterAddress) external payable {
+        currentSplitterAddress = splitterAddress;
+        (bool success, ) = splitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+    }
+}

package/contracts/randomizer/primitive/PseudorandomAtomicBasic.sol

@@ -10,7 +10,7 @@ import "../../interfaces/v0.8.x/IPseudorandomAtomic.sol";
  * @author Art Blocks Inc.
  * @notice This contract atomically returns a pseudorandom value.
  */
-contract PseudorandomAtomic {
+contract PseudorandomAtomic is IPseudorandomAtomic {
     // base class that returns
     function getPseudorandomAtomic(
         bytes32 _entropy

package/contracts/randomizer/shared/SharedRandomizerV0.sol

@@ -248,7 +248,7 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
     function _getPseudorandomAtomic(
         address coreContract,
         uint256 tokenId
-    ) internal view returns (bytes32) {
+    ) internal returns (bytes32) {
         return
             pseudorandomAtomicContract.getPseudorandomAtomic(
                 keccak256(abi.encodePacked(coreContract, tokenId))

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