@artblocks/contracts 1.0.4 → 1.2.0

package/contracts/mock/ReentrancyMerkleMockShared.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/ISharedMinterMerkleV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyMerkleMockShared {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    address public currentCoreContract;
+    uint256 public currentPriceToPay;
+    bytes32[3] currentProof;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on the shared 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,
+        address _coreContract,
+        uint256 _priceToPay,
+        bytes32[] memory _proof
+    ) external payable {
+        // update state variables so that receive() knows what to do
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentCoreContract = _coreContract;
+        currentPriceToPay = _priceToPay;
+        currentProof[0] = _proof[0];
+        currentProof[1] = _proof[1];
+        currentProof[2] = _proof[2];
+        ISharedMinterMerkleV0(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _coreContract, _proof);
+    }
+
+    // receiver is called when minter sends refunded Ether to this contract.
+    receive() external payable {
+        // decrement num to be purchased
+        currentQtyToPurchase--;
+        if (currentQtyToPurchase > 0) {
+            // rebuild _proof
+            bytes32[] memory _proof = new bytes32[](3);
+            _proof[0] = currentProof[0];
+            _proof[1] = currentProof[1];
+            _proof[2] = currentProof[2];
+            // purchase again!
+            ISharedMinterMerkleV0(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, currentCoreContract, _proof);
+        }
+    }
+}

package/contracts/mock/ReentrancyMockShared.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/ISharedMinterSimplePurchaseV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyMockShared {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    address public currentCoreContract;
+    uint256 public currentPriceToPay;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on the shared 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,
+        address _coreContract,
+        uint256 _priceToPay
+    ) external payable {
+        // update state variables so that receive() knows what to do
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentCoreContract = _coreContract;
+        currentPriceToPay = _priceToPay;
+        ISharedMinterSimplePurchaseV0(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _coreContract);
+    }
+
+    // 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!
+            ISharedMinterSimplePurchaseV0(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, currentCoreContract);
+        }
+    }
+}

package/contracts/mock/ReentrancySEAMockShared.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/ISharedMinterSEAV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancySEAAutoBidderMockShared {
+    uint256 public targetTokenId;
+    address public targetCoreContract;
+
+    /**
+        @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 _targetTokenId,
+        address _targetCoreContract,
+        address _minterContractAddress,
+        uint256 _initialBidValue
+    ) external payable {
+        targetTokenId = _targetTokenId;
+        targetCoreContract = _targetCoreContract;
+        ISharedMinterSEAV0(_minterContractAddress).createBid{
+            value: _initialBidValue
+        }(_targetTokenId, _targetCoreContract);
+    }
+
+    // receiver is called when minter sends refunded Ether to this contract, when outbid
+    receive() external payable {
+        // auto-rebid
+        uint256 newBidValue = (msg.value * 110) / 100;
+        ISharedMinterSEAV0(msg.sender).createBid{value: newBidValue}(
+            targetTokenId,
+            targetCoreContract
+        );
+    }
+}

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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
 pragma solidity 0.8.19;
 
 import "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
@@ -59,26 +61,26 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
     // @dev this mapping is only used when the project is configured as using
     // a hash seed setter contract. It is not populated when the project is
     // using pseudorandomAtomicContract.
-    mapping(address => mapping(uint256 => bytes12))
+    mapping(address coreContract => mapping(uint256 tokenId => bytes12 preAssignedHashSeed))
         private _preAssignedHashSeeds;
 
     // mapping of core contract => project ID => usesHashSeedSetter Contract
-    mapping(address => mapping(uint256 => bool))
+    mapping(address coreContract => mapping(uint256 projectId => bool usesHashSeedSetter))
         private _projectUsesHashSeedSetter;
 
     // mapping of core contract => projectId => hash seed setter contract
-    mapping(address => mapping(uint256 => address))
+    mapping(address coreContract => mapping(uint256 projectId => address hashSeedSetterContract))
         private _hashSeedSetterContracts;
 
     // modifier to restrict access to only Artist allowed calls
     function _onlyArtist(
-        address _coreContract,
-        uint256 _projectId
+        address coreContract,
+        uint256 projectId
     ) internal view {
         require(
             msg.sender ==
-                IGenArt721CoreContractV3_Base(_coreContract)
-                    .projectIdToArtistAddress(_projectId),
+                IGenArt721CoreContractV3_Base(coreContract)
+                    .projectIdToArtistAddress(projectId),
             "Only Artist"
         );
     }
@@ -86,32 +88,32 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
     /**
      * Modifier to restrict access to only calls by the hash seed setter
      * contract of a given project.
-     * @param _coreContract core contract address associated with the project
-     * @param _projectId project ID being set
+     * @param coreContract core contract address associated with the project
+     * @param projectId project ID being set
      */
     function _onlyHashSeedSetterContract(
-        address _coreContract,
-        uint256 _projectId
+        address coreContract,
+        uint256 projectId
     ) internal view {
         require(
-            msg.sender == _hashSeedSetterContracts[_coreContract][_projectId],
+            msg.sender == _hashSeedSetterContracts[coreContract][projectId],
             "Only Hash Seed Setter Contract"
         );
     }
 
     /**
      *
-     * @param _pseudorandomAtomicContract Address of the pseudorandom atomic
+     * @param pseudorandomAtomicContract_ Address of the pseudorandom atomic
      * contract to use for atomically generating random values. This contract
      * does not have an owner, and therefore the pseudorandom atomic contract
      * address cannot be changed after deployment.
      */
-    constructor(address _pseudorandomAtomicContract) {
+    constructor(address pseudorandomAtomicContract_) {
         pseudorandomAtomicContract = IPseudorandomAtomic(
-            _pseudorandomAtomicContract
+            pseudorandomAtomicContract_
         );
         emit PseudorandomAtomicContractUpdated({
-            pseudorandomAtomicContract: _pseudorandomAtomicContract
+            pseudorandomAtomicContract: pseudorandomAtomicContract_
         });
     }
 
@@ -119,18 +121,18 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
      * @inheritdoc ISharedRandomizerV0
      */
     function setHashSeedSetterContract(
-        address _coreContract,
-        uint256 _projectId,
-        address _hashSeedSetterContract
+        address coreContract,
+        uint256 projectId,
+        address hashSeedSetterContract
     ) external {
-        _onlyArtist(_coreContract, _projectId);
-        _hashSeedSetterContracts[_coreContract][
-            _projectId
-        ] = _hashSeedSetterContract;
+        _onlyArtist({projectId: projectId, coreContract: coreContract});
+        _hashSeedSetterContracts[coreContract][
+            projectId
+        ] = hashSeedSetterContract;
         emit HashSeedSetterForProjectUpdated({
-            coreContract: _coreContract,
-            projectId: _projectId,
-            hashSeedSetterContract: _hashSeedSetterContract
+            coreContract: coreContract,
+            projectId: projectId,
+            hashSeedSetterContract: hashSeedSetterContract
         });
     }
 
@@ -138,18 +140,18 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
      * @inheritdoc ISharedRandomizerV0
      */
     function toggleProjectUseAssignedHashSeed(
-        address _coreContract,
-        uint256 _projectId
+        address coreContract,
+        uint256 projectId
     ) external {
-        _onlyArtist(_coreContract, _projectId);
-        _projectUsesHashSeedSetter[_coreContract][
-            _projectId
-        ] = !_projectUsesHashSeedSetter[_coreContract][_projectId];
+        _onlyArtist({projectId: projectId, coreContract: coreContract});
+        _projectUsesHashSeedSetter[coreContract][
+            projectId
+        ] = !_projectUsesHashSeedSetter[coreContract][projectId];
         emit ProjectUsingHashSeedSetterUpdated({
-            coreContract: _coreContract,
-            projectId: _projectId,
-            usingHashSeedSetter: _projectUsesHashSeedSetter[_coreContract][
-                _projectId
+            coreContract: coreContract,
+            projectId: projectId,
+            usingHashSeedSetter: _projectUsesHashSeedSetter[coreContract][
+                projectId
             ]
         });
     }
@@ -158,13 +160,16 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
      * @inheritdoc ISharedRandomizerV0
      */
     function preSetHashSeed(
-        address _coreContract,
-        uint256 _tokenId,
-        bytes12 _hashSeed
+        address coreContract,
+        uint256 tokenId,
+        bytes12 hashSeed
     ) external {
-        uint256 projectId = _tokenIdToProjectId(_tokenId);
-        _onlyHashSeedSetterContract(_coreContract, projectId);
-        _preAssignedHashSeeds[_coreContract][_tokenId] = _hashSeed;
+        uint256 projectId = _tokenIdToProjectId(tokenId);
+        _onlyHashSeedSetterContract({
+            projectId: projectId,
+            coreContract: coreContract
+        });
+        _preAssignedHashSeeds[coreContract][tokenId] = hashSeed;
         // @dev event indicating token hash seed assigned is not required for
         // subgraph indexing because token hash seeds are still assigned
         // atomically in `assignTokenHash` function. If token hash seeds were
@@ -175,7 +180,7 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
     /**
      * @inheritdoc IRandomizer_V3CoreBase
      */
-    function assignTokenHash(uint256 _tokenId) external {
+    function assignTokenHash(uint256 tokenId) external {
         // @dev This function is not specifically gated to any specific caller,
         // but will only call back to the calling contract, `msg.sender`, to
         // set the specified token's hash seed.
@@ -183,78 +188,81 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
         // the token hash seed on a different core contract.
         // @dev variables are named to improve readability
         address coreContract = msg.sender;
-        uint256 projectId = _tokenIdToProjectId(_tokenId);
+        uint256 projectId = _tokenIdToProjectId(tokenId);
         bytes32 hashSeed;
         if (_projectUsesHashSeedSetter[coreContract][projectId]) {
-            hashSeed = _preAssignedHashSeeds[coreContract][_tokenId];
+            hashSeed = _preAssignedHashSeeds[coreContract][tokenId];
         } else {
-            hashSeed = _getPseudorandomAtomic(coreContract, _tokenId);
+            hashSeed = _getPseudorandomAtomic({
+                coreContract: coreContract,
+                tokenId: tokenId
+            });
         }
         // verify that the hash seed is non-zero
         require(hashSeed != 0, "Only non-zero hash seed");
         // assign the token hash seed on the core contract
-        IGenArt721CoreContractV3_Base(coreContract).setTokenHash_8PT(
-            _tokenId,
-            hashSeed
-        );
+        IGenArt721CoreContractV3_Base(coreContract).setTokenHash_8PT({
+            _tokenId: tokenId,
+            _hash: hashSeed
+        });
     }
 
     /**
      * @inheritdoc ISharedRandomizerV0
      */
     function projectUsesHashSeedSetter(
-        address _coreContract,
-        uint256 _projectId
-    ) external view returns (bool _usingHashSeedSetter) {
-        return _projectUsesHashSeedSetter[_coreContract][_projectId];
+        address coreContract,
+        uint256 projectId
+    ) external view returns (bool usingHashSeedSetter) {
+        return _projectUsesHashSeedSetter[coreContract][projectId];
     }
 
     /**
      * @inheritdoc ISharedRandomizerV0
      */
     function hashSeedSetterContracts(
-        address _coreContract,
-        uint256 _projectId
+        address coreContract,
+        uint256 projectId
     ) external view returns (address _hashSeedSetterContract) {
-        return _hashSeedSetterContracts[_coreContract][_projectId];
+        return _hashSeedSetterContracts[coreContract][projectId];
     }
 
     /**
      * @inheritdoc ISharedRandomizerV0
      */
     function preAssignedHashSeed(
-        address _coreContract,
-        uint256 _tokenId
+        address coreContract,
+        uint256 tokenId
     ) external view returns (bytes12 _hashSeed) {
-        return _preAssignedHashSeeds[_coreContract][_tokenId];
+        return _preAssignedHashSeeds[coreContract][tokenId];
     }
 
     /**
      * @notice Internal function to atomically obtain a pseudorandom number
      * from the configured pseudorandom contract.
-     * @param _coreContract - The core contract that is requesting an atomic
+     * @param coreContract - The core contract that is requesting an atomic
      * pseudorandom number.
-     * @param _tokenId - The token ID on `_coreContract` that is associated
+     * @param tokenId - The token ID on `coreContract` that is associated
      * with the pseudorandom number request.
      */
     function _getPseudorandomAtomic(
-        address _coreContract,
-        uint256 _tokenId
-    ) internal view returns (bytes32) {
+        address coreContract,
+        uint256 tokenId
+    ) internal returns (bytes32) {
         return
             pseudorandomAtomicContract.getPseudorandomAtomic(
-                keccak256(abi.encodePacked(_coreContract, _tokenId))
+                keccak256(abi.encodePacked(coreContract, tokenId))
             );
     }
 
     /**
-     * @notice Gets the project ID for a given `_tokenId`.
-     * @param _tokenId Token ID to be queried.
-     * @return projectId Project ID for given `_tokenId`.
+     * @notice Gets the project ID for a given `tokenId`.
+     * @param tokenId Token ID to be queried.
+     * @return projectId Project ID for given `tokenId`.
      */
     function _tokenIdToProjectId(
-        uint256 _tokenId
+        uint256 tokenId
     ) internal pure returns (uint256 projectId) {
-        return _tokenId / ONE_MILLION;
+        return tokenId / ONE_MILLION;
     }
 }

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