@artblocks/contracts 1.0.1 → 1.0.3

package/contracts/mock/GenArt721CoreV3_Engine_IncorrectCoreType.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-only
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 // Created By: Art Blocks Inc.
 
@@ -13,7 +13,7 @@ import "../interfaces/0.8.x/IManifold.sol";
 import "@openzeppelin-4.7/contracts/utils/Strings.sol";
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";
 import "../libs/0.8.x/ERC721_PackedHashSeed.sol";
-import "../libs/0.8.x/BytecodeStorage.sol";
+import "../libs/0.8.x/BytecodeStorageV1.sol";
 import "../libs/0.8.x/Bytes32Strings.sol";
 
 /**
@@ -30,8 +30,7 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     IManifold
     // INTERFACE CONFORMANCE INTENTIONALLY OMITTED TO ENABLE MOCKING BUGGED CONTRACT
 {
-    using BytecodeStorage for string;
-    using BytecodeStorage for address;
+    using BytecodeStorageWriter for string;
     using Bytes32Strings for bytes32;
     using Strings for uint256;
     using Strings for address;
@@ -1115,16 +1114,6 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     {
         Project storage project = projects[_projectId];
         require(_scriptId < project.scriptCount, "scriptId out of range");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project.scriptBytecodeAddresses[_scriptId].purgeBytecode();
         // store script in contract bytecode, replacing reference address from
         // the contract that no longer exists with the newly created one
         project.scriptBytecodeAddresses[_scriptId] = _script.writeToBytecode();
@@ -1144,18 +1133,6 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     {
         Project storage project = projects[_projectId];
         require(project.scriptCount > 0, "there are no scripts to remove");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project
-            .scriptBytecodeAddresses[project.scriptCount - 1]
-            .purgeBytecode();
         // delete reference to contract address that no longer exists
         delete project.scriptBytecodeAddresses[project.scriptCount - 1];
         unchecked {
@@ -1580,7 +1557,7 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
         if (_index >= project.scriptCount) {
             return "";
         }
-        return project.scriptBytecodeAddresses[_index].readFromBytecode();
+        return _readFromBytecode(project.scriptBytecodeAddresses[_index]);
     }
 
     /**
@@ -1976,4 +1953,14 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
             (block.timestamp - projectCompletedTimestamp <
                 FOUR_WEEKS_IN_SECONDS);
     }
+
+    /**
+     * Helper for calling `BytecodeStorageReader` external library reader method,
+     * added for bytecode size reduction purposes.
+     */
+    function _readFromBytecode(
+        address _address
+    ) internal view returns (string memory) {
+        return BytecodeStorageReader.readFromBytecode(_address);
+    }
 }

package/contracts/mock/MockAdminACLV0.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 import "../interfaces/0.8.x/IAdminACLV0.sol";
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";

package/contracts/mock/MockAdminACLV0_PROHIBITION.sol

@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../engine/V3/forks/PROHIBITION/interfaces/IAdminACLV0_PROHIBITION.sol";
+import "../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "@openzeppelin-4.7/contracts/access/Ownable.sol";
+import "@openzeppelin-4.7/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract has a single superAdmin that passes all ACL checks. All checks
+ * for any other address will return false.
+ * It also emits an event for all ACL checks, enabling our test suite to verify
+ * that the ACL was checked with the correct parameters.
+ * @dev this contract specifically does not broadcast conformance to IAdminACLV0
+ * for testing purposes.
+ */
+contract MockAdminACLV0Events_PROHIBITION is IAdminACLV0_PROHIBITION, ERC165 {
+    // event used for testing purposes to diagnose what core contract is asking
+    // approval for.
+    event ACLCheck(address indexed sender, bytes4 indexed selector);
+
+    string public AdminACLType = "MockAdminACLV0Events_PROHIBITION";
+
+    // superAdmin is the only address that passes any and all ACL checks
+    address public superAdmin;
+
+    /// approvedCallers is a mapping of keccak256(contracts,  selectors, account) -> approved to call.
+    /// It is used to determine if an account is approved to call a function on specific contracts.
+    mapping(bytes32 => bool) public contractSelectorApprovals;
+    /// contractArtistApprovals is a mapping of:
+    ///   keccak256(contracts, artist) -> approved to call.
+    /// It is used to determine if an account is approved to call a functions for specific projects.
+    mapping(bytes32 => bool) public contractArtistApprovals;
+
+    constructor() {
+        superAdmin = msg.sender;
+    }
+
+    /**
+     * @dev Retrieve the address of the caller that is allowed to call a contract's function
+     */
+    function getContractSelectorApproval(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) external view returns (bool) {
+        return
+            contractSelectorApprovals[
+                hashSelectorApprovalKey(_contract, _selector, _caller)
+            ];
+    }
+
+    /**
+     * @dev Retrieve whether of the caller is allowed to call a functions for a project
+     */
+    function getContractArtistApproval(
+        address _contract,
+        address _caller
+    ) external view returns (bool) {
+        return
+            contractArtistApprovals[hashArtistApprovalKey(_contract, _caller)];
+    }
+
+    /**
+     * @dev Allows superAdmin to set a contract function caller.
+     */
+    function toggleContractSelectorApproval(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) external {
+        require(
+            allowed(
+                msg.sender,
+                address(this),
+                this.toggleContractSelectorApproval.selector
+            ),
+            "Only superAdmin or allowed caller"
+        );
+
+        bytes32 approvalHash = hashSelectorApprovalKey(
+            _contract,
+            _selector,
+            _caller
+        );
+        contractSelectorApprovals[approvalHash] = !contractSelectorApprovals[
+            approvalHash
+        ];
+        emit ContractSelectorApprovalUpdated(
+            _contract,
+            _selector,
+            _caller,
+            contractSelectorApprovals[approvalHash]
+        );
+    }
+
+    /**
+     * @dev Toggles verification for artists to call functions relating to their projects on a contract
+     */
+    function toggleContractArtistApproval(
+        address _contract,
+        address _artist
+    ) external {
+        require(
+            allowed(
+                msg.sender,
+                address(this),
+                this.toggleContractArtistApproval.selector
+            ),
+            "Only allowed caller"
+        );
+
+        bytes32 approvalHash = hashArtistApprovalKey(_contract, _artist);
+        contractSelectorApprovals[approvalHash] = !contractSelectorApprovals[
+            approvalHash
+        ];
+        emit ContractArtistApprovalUpdated(
+            _contract,
+            _artist,
+            contractArtistApprovals[approvalHash]
+        );
+    }
+
+    /**
+     * @dev Checks if sender `_sender` is allowed to call function with selector
+     * `_selector` on contract `_contract`. Returns true if sender is superAdmin.
+     * Also emits event for testing purposes.
+     */
+    function allowed(
+        address _sender,
+        address _contract,
+        bytes4 _selector
+    ) public returns (bool) {
+        emit ACLCheck(_sender, _selector);
+        return
+            superAdmin == _sender ||
+            contractSelectorApprovals[
+                hashSelectorApprovalKey(_contract, _selector, _sender)
+            ];
+    }
+
+    /**
+     * @dev Checks if sender `_sender` is allowed to call function (or functions for projects) with
+     * method `_selector` on `_contract`. Returns true if sender is superAdmin.
+     * @dev this function is public insteaad of internal so that the right to toggle approvals can also be delegated
+     */
+    function allowed(
+        address _sender,
+        address _contract,
+        bytes4 _selector,
+        uint256 _projectId
+    ) external returns (bool) {
+        emit ACLCheck(_sender, _selector);
+        IGenArt721CoreContractV3_Base coreV3 = IGenArt721CoreContractV3_Base(
+            _contract
+        );
+        return
+            allowed(_sender, _contract, _selector) ||
+            (contractArtistApprovals[
+                hashArtistApprovalKey(_contract, _sender)
+            ] && coreV3.projectIdToArtistAddress(_projectId) == _sender);
+    }
+
+    /**
+     * @dev Hash the contract address, selector, and caller address.
+     */
+    function hashSelectorApprovalKey(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_contract, _selector, _caller));
+    }
+
+    /**
+     * @dev Hash the contract address and artist address.
+     */
+    function hashArtistApprovalKey(
+        address _contract,
+        address _artist
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_contract, _artist));
+    }
+
+    /**
+     * @dev Allows superAdmin to call transferOwnership on other contract from
+     * this contract.
+     */
+    function transferOwnershipOn(
+        address _contract,
+        address _newAdminACL
+    ) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        Ownable(_contract).transferOwnership(_newAdminACL);
+    }
+
+    /**
+     * @dev Allows superAdmin to call renounceOwnership on other contract from
+     * this contract.
+     */
+    function renounceOwnershipOn(address _contract) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        Ownable(_contract).renounceOwnership();
+    }
+}

package/contracts/mock/OriginRegisterMock.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.19;
+
+import {ICoreRegistryV1} from "../interfaces/0.8.x/ICoreRegistryV1.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract hijacks a tx with origin of a core registry's owner, and
+ * attempts to register a contract with the registry.
+ * Note that mock could forward on additional requests to contracts that only
+ * register "themselves", and could be successfully registered.
+ */
+contract OriginRegisterMock {
+    function registerOther(
+        address _registry,
+        address _contract,
+        bytes32 _coreVersion,
+        bytes32 _coreType
+    ) external {
+        ICoreRegistryV1(_registry).registerContract(
+            _contract,
+            _coreVersion,
+            _coreType
+        );
+    }
+}

package/contracts/mock/RandomizerV2_NoAssignMock.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
-import "../BasicRandomizerV2.sol";
+import "../randomizer/deprecated/RandomizerV2.sol";
 
 /// @title RandomizerV2_NoAssignMock
 /// @notice WARNING - This is a mock contract. Do not use it in production.
@@ -20,16 +20,7 @@ contract RandomizerV2_NoAssignMock is BasicRandomizerV2 {
     // on the core contract. Used for test purposes only.
     // @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
     function actuallyAssignTokenHash(uint256 _tokenId) external {
-        uint256 time = block.timestamp;
-        bytes32 hash = keccak256(
-            abi.encodePacked(
-                _tokenId,
-                block.number,
-                blockhash(block.number - 1),
-                time,
-                (time % 200) + 1
-            )
-        );
+        bytes32 hash = _getPseudorandom(_tokenId);
         genArt721Core.setTokenHash_8PT(_tokenId, hash);
     }
 

package/contracts/mock/ReentrancySEAMock.sol

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

package/contracts/mock/SSTORE2Mock.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import "../libs/0.8.x/SSTORE2.sol";
+
+/**
+ * @title Art Blocks SSTORE2Mock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the SSTORE2 library
+ *         to allow for more testing of this library in the context of
+ *         backwards-compatible reads with the Art Blocks BytecodeStorage library
+ * @dev For the purposes of our backwards-compatibility testing, the two different
+ *      variations of the SSTORE2 library are functionally equivalent, so we just test
+ *      against the one that is more widely tracked on Github for simplicity, but the
+ *      same tests could be run against the other variation of the library as well
+ *      and would be expected to "just work" given both use the same data offset of
+ *      a single 0x00 "stop byte".
+ */
+contract SSTORE2Mock {
+    using SSTORE2 for bytes;
+    using SSTORE2 for address;
+
+    // monotonically increasing slot counter and associated slot-storage mapping
+    uint256 public nextTextSlotId = 0;
+    mapping(uint256 => address) public storedTextBytecodeAddresses;
+
+    // save deployer address to support basic ACL checks for non-read operations
+    address public deployerAddress;
+
+    modifier onlyDeployer() {
+        require(msg.sender == deployerAddress, "Only deployer");
+        _;
+    }
+
+    /**
+     * @notice Initializes contract.
+     */
+    constructor() {
+        deployerAddress = msg.sender;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                     Create + Read
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice "Create": Adds a chunk of text to be stored to chain-state.
+     * @param _text Text to be created in chain-state.
+     * @return uint256 Slot that the written bytecode contract address was
+     *         stored in.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function createText(
+        string memory _text
+    ) external onlyDeployer returns (uint256) {
+        // store text in contract bytecode
+        storedTextBytecodeAddresses[nextTextSlotId] = bytes(_text).write();
+        // record written slot before incrementing
+        uint256 textSlotId = nextTextSlotId;
+        nextTextSlotId++;
+        return textSlotId;
+    }
+
+    /**
+     * @notice "Read": Reads chunk of text currently in the provided slot, from
+     *                 chain-state.
+     * @param _textSlotId Slot (associated with this contract) for which to
+     *                   read text content.
+     * @return string Content read from contract bytecode in the given slot.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readText(uint256 _textSlotId) public view returns (string memory) {
+        return string(storedTextBytecodeAddresses[_textSlotId].read());
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address.
+     * @param _bytecodeAddress address from which to read text content.
+     * @return string Content read from contract bytecode at the given address.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (string memory) {
+        return string(_bytecodeAddress.read());
+    }
+}

package/contracts/{BasicRandomizer.sol → randomizer/deprecated/BasicRandomizer.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-import "./interfaces/0.8.x/IRandomizer.sol";
+import "../../interfaces/0.8.x/IRandomizer.sol";
 
 pragma solidity 0.8.9;
 

package/contracts/randomizer/deprecated/BasicRandomizerBase_v0_0_0.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity 0.8.19;
+
+abstract contract RandomizerBase {
+    // base class that returns
+    function _getPseudorandom(
+        uint256 _tokenId
+    ) internal virtual returns (bytes32) {
+        uint256 time = block.timestamp;
+        return
+            keccak256(
+                abi.encodePacked(
+                    _tokenId,
+                    block.number,
+                    blockhash(block.number - 1),
+                    time,
+                    (time % 200) + 1
+                )
+            );
+    }
+}

package/contracts/{BasicPolyptychRandomizerV0.sol → randomizer/deprecated/PolyptychRandomizerV0.sol}

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
-import "./interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
-import "./interfaces/0.8.x/IRandomizerPolyptychV0.sol";
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "../../interfaces/0.8.x/IRandomizerPolyptychV0.sol";
+import "./BasicRandomizerBase_v0_0_0.sol";
 
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";
 
@@ -23,7 +24,11 @@ import "@openzeppelin-4.7/contracts/access/Ownable.sol";
  * Once the contract is configured, it will enable newly-minted tokens to use a copy of the hash
  * seed from a previously-minted token.
  */
-contract BasicPolyptychRandomizerV0 is IRandomizerPolyptychV0, Ownable {
+contract BasicPolyptychRandomizerV0 is
+    IRandomizerPolyptychV0,
+    RandomizerBase,
+    Ownable
+{
     // The core contract that may interact with this randomizer contract.
     IGenArt721CoreContractV3_Base public genArt721Core;
 
@@ -46,26 +51,23 @@ contract BasicPolyptychRandomizerV0 is IRandomizerPolyptychV0, Ownable {
 
     // modifier to restrict access to only AdminACL allowed calls
     // @dev defers which ACL contract is used to the core contract
-    modifier onlyCoreAdminACL(bytes4 _selector) {
+    function _onlyCoreAdminACL(bytes4 _selector) internal {
         require(
             genArt721Core.adminACLAllowed(msg.sender, address(this), _selector),
             "Only Core AdminACL allowed"
         );
-        _;
     }
 
-    modifier onlyArtist(uint256 _projectId) {
+    function _onlyArtist(uint256 _projectId) internal view {
         require(
             msg.sender == genArt721Core.projectIdToArtistAddress(_projectId),
             "Only Artist"
         );
-        _;
     }
 
     // Allows the owner of the core contract to set the minter that is allowed to assign hash seeds
-    function setHashSeedSetterContract(
-        address _contractAddress
-    ) external onlyCoreAdminACL(this.setHashSeedSetterContract.selector) {
+    function setHashSeedSetterContract(address _contractAddress) external {
+        _onlyCoreAdminACL(this.setHashSeedSetterContract.selector);
         hashSeedSetterContract = _contractAddress;
         emit HashSeedSetterUpdated(_contractAddress);
     }
@@ -74,9 +76,8 @@ contract BasicPolyptychRandomizerV0 is IRandomizerPolyptychV0, Ownable {
      * @notice Allows the owner of the core contract to configure a project as a polyptych
      * @param _projectId - The ID of the project that has a polyptych panel (second, third, etc.)
      */
-    function toggleProjectIsPolyptych(
-        uint256 _projectId
-    ) external onlyArtist(_projectId) {
+    function toggleProjectIsPolyptych(uint256 _projectId) external {
+        _onlyArtist(_projectId);
         projectIsPolyptych[_projectId] = !projectIsPolyptych[_projectId];
         emit ProjectIsPolyptychUpdated(
             _projectId,
@@ -104,23 +105,13 @@ contract BasicPolyptychRandomizerV0 is IRandomizerPolyptychV0, Ownable {
     // will set a bytes32 hash for tokenId `_tokenId` on the core contract.
     function assignTokenHash(uint256 _tokenId) external virtual {
         require(msg.sender == address(genArt721Core), "Only core may call");
-
+        bytes32 hash;
         if (projectIsPolyptych[_tokenId / ONE_MILLION]) {
-            bytes12 seededHash = polyptychHashSeeds[_tokenId];
-            require(seededHash != 0, "Only non-zero hash seed");
-            genArt721Core.setTokenHash_8PT(_tokenId, seededHash);
+            hash = polyptychHashSeeds[_tokenId];
         } else {
-            uint256 time = block.timestamp;
-            bytes32 hash = keccak256(
-                abi.encodePacked(
-                    _tokenId,
-                    block.number,
-                    blockhash(block.number - 1),
-                    time,
-                    (time % 200) + 1
-                )
-            );
-            genArt721Core.setTokenHash_8PT(_tokenId, hash);
+            hash = _getPseudorandom(_tokenId);
         }
+        require(hash != 0, "Only non-zero hash seed");
+        genArt721Core.setTokenHash_8PT(_tokenId, hash);
     }
 }

package/contracts/{BasicRandomizerV2.sol → randomizer/deprecated/RandomizerV2.sol}

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Creatd By: Art Blocks Inc.
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
-import "./interfaces/0.8.x/IRandomizerV2.sol";
-import "./interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "../../interfaces/0.8.x/IRandomizerV2.sol";
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "./BasicRandomizerBase_v0_0_0.sol";
 
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";
 
-contract BasicRandomizerV2 is IRandomizerV2, Ownable {
+contract BasicRandomizerV2 is IRandomizerV2, RandomizerBase, Ownable {
     // The core contract that may interact with this randomizer contract.
     IGenArt721CoreContractV3_Base public genArt721Core;
 
@@ -21,16 +22,7 @@ contract BasicRandomizerV2 is IRandomizerV2, Ownable {
     // will set a bytes32 hash for tokenId `_tokenId` on the core contract.
     function assignTokenHash(uint256 _tokenId) external virtual {
         require(msg.sender == address(genArt721Core), "Only core may call");
-        uint256 time = block.timestamp;
-        bytes32 hash = keccak256(
-            abi.encodePacked(
-                _tokenId,
-                block.number,
-                blockhash(block.number - 1),
-                time,
-                (time % 200) + 1
-            )
-        );
+        bytes32 hash = _getPseudorandom(_tokenId);
         genArt721Core.setTokenHash_8PT(_tokenId, hash);
     }
 }