@artblocks/contracts 1.1.0 → 1.2.1

package/contracts/mock/BytecodeV2LibCallsMock.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import {IBytecodeStorageReaderV2} from "../interfaces/v0.8.x/IBytecodeStorageReaderV2.sol";
+
+/**
+ * @title Art Blocks IBytecodeStorageReader-conforming mock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorageV2 library
+ *         to allow for testing of making direct calls (rather than delegate calls)
+ *         to a deployed copy of the library. This is for testing purposes as this
+ *         is the expected integration flow for direct usage of the BytecodeStorageV2
+ *         reader library in a post-EOF world where new EOF-contracts cannot DELEGATECALL
+ *         into legacy contracts, in which we plan to have a BytecodeStorageV3 variant
+ *         of the library that makes use of CALL rather than DELEGATECALL for the
+ *         purposes of backwards-compatible reads.
+ */
+contract BytecodeV2LibCallsMock {
+    // Address of the deployed BytecodeStorageReader contract library under mock harness.
+    address public bytecodeStorageReaderDeploymentAddress;
+    // Deployed instance of the BytecodeStorageReader contract library under mock harness.
+    IBytecodeStorageReaderV2 private bytecodeStorageReaderDeployment;
+
+    /**
+     * @notice Initializes contract.
+     */
+    constructor(address _bytecodeStorageReaderDeploymentAddress) {
+        bytecodeStorageReaderDeploymentAddress = _bytecodeStorageReaderDeploymentAddress;
+        bytecodeStorageReaderDeployment = IBytecodeStorageReaderV2(
+            _bytecodeStorageReaderDeploymentAddress
+        );
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                Proxy Read Operations of V2 Library
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Read a string from contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0, V1, or V2 format
+     * @return data string read from contract bytecode
+     * @dev This function performs input validation that the contract to read is in an expected format
+     */
+    function readFromBytecode(
+        address _address
+    ) public view returns (string memory data) {
+        return bytecodeStorageReaderDeployment.readFromBytecode(_address);
+    }
+
+    /**
+     * @notice Read the bytes from contract bytecode that was written to the EVM using SSTORE2
+     * @param _address address of deployed contract with bytecode stored in the SSTORE2 format
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address _address
+    ) public view returns (bytes memory data) {
+        return
+            bytecodeStorageReaderDeployment.readBytesFromSSTORE2Bytecode(
+                _address
+            );
+    }
+
+    /**
+     * @notice Read the bytes from contract bytecode, with an explicitly provided starting offset
+     * @param _address address of deployed contract with bytecode stored in the V0, V1 or V2 format
+     * @param _offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromBytecode(
+        address _address,
+        uint256 _offset
+    ) public view returns (bytes memory data) {
+        return
+            bytecodeStorageReaderDeployment.readBytesFromBytecode(
+                _address,
+                _offset
+            );
+    }
+
+    /**
+     * @notice Get address for deployer for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0, V1 or V2 format
+     * @return writerAddress address read from contract bytecode
+     */
+    function getWriterAddressForBytecode(
+        address _address
+    ) public view returns (address) {
+        return
+            bytecodeStorageReaderDeployment.getWriterAddressForBytecode(
+                _address
+            );
+    }
+
+    /**
+     * @notice Get version for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0, V1 or V2 format
+     * @return version version read from contract bytecode
+     */
+    function getLibraryVersionForBytecode(
+        address _address
+    ) public view returns (bytes32) {
+        return
+            bytecodeStorageReaderDeployment.getLibraryVersionForBytecode(
+                _address
+            );
+    }
+
+    /**
+     * @notice Get if using compressed storage for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0, V1, or V2 format
+     * @return isCompressed boolean indicating if the stored data are compressed
+     */
+    function getIsCompressedForBytecode(
+        address _address
+    ) public view returns (bool) {
+        return
+            bytecodeStorageReaderDeployment.getIsCompressedForBytecode(
+                _address
+            );
+    }
+}

package/contracts/mock/BytecodeV2TextCR_DMock.sol

@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import {BytecodeStorageWriter, BytecodeStorageReader} from "../libs/v0.8.x/BytecodeStorageV2.sol";
+
+/**
+ * @title Art Blocks BytecodeTextCR_DMock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorageV2 library
+ *         to allow for more granular testing of this library than is supported
+ *         by the usage of the library directly by specific current Art Blocks
+ *         client smart contracts, such as the `GenArt721CoreV3` contract. This
+ *         mock exposes the CR_D (create, read, _not updates_, delete)
+ *         operations that the underlying BytecodeStorageV2 library allows clients
+ *         to support.
+ *         Note that because updates can only functionally be performed by
+ *         combining a "delete" and "create" operation, given that deployed
+ *         contracts cannot be _updated_ directly in chain-state, this mock does
+ *         not expose updates (the usual "U" in "CRUD") as they are not
+ *         supported by the underlying library.
+ */
+contract BytecodeV2TextCR_DMock {
+    using BytecodeStorageWriter for string;
+    using BytecodeStorageReader for string;
+    using BytecodeStorageWriter for bytes;
+
+    // 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;
+
+    // dummy counter to implement non-view read function for gas measurements of large reads (RPC compatibility)
+    uint256 private _dummyCounter;
+
+    modifier onlyDeployer() {
+        require(msg.sender == deployerAddress, "Only deployer");
+        _;
+    }
+
+    /**
+     * @notice Initializes contract.
+     */
+    constructor() {
+        deployerAddress = msg.sender;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                     Create Read _ Delete
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @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] = _text.writeToBytecode();
+        // record written slot before incrementing
+        uint256 textSlotId = nextTextSlotId;
+        nextTextSlotId++;
+        return textSlotId;
+    }
+
+    /**
+     * @notice "Create": Adds a chunk of text to be stored to chain-state.
+     * @param _textCompressed Compressed bytes representing 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 createTextCompressed(
+        bytes memory _textCompressed
+    ) external onlyDeployer returns (uint256) {
+        // store compressed text in contract bytecode
+        storedTextBytecodeAddresses[nextTextSlotId] = _textCompressed
+            .writeToBytecodeCompressed();
+        // 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
+            BytecodeStorageReader.readFromBytecode(
+                storedTextBytecodeAddresses[_textSlotId]
+            );
+    }
+
+    /**
+     * @notice "Delete": Deletes chunk of text currently in the provided slot,
+     *                   from chain-state.
+     * @param _textSlotId Slot (associated with this contract) for which to
+     *                    delete text content.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function deleteText(uint256 _textSlotId) external onlyDeployer {
+        // delete reference to old storage contract address
+        delete storedTextBytecodeAddresses[_textSlotId];
+    }
+
+    /**
+     * @notice function to assist in getting compressed text in a non-view function.
+     * Useful for measuring gas costs of large reads in RPC environments.
+     * @param _text Text to be compressed.
+     */
+    function getCompressedNonView(
+        string memory _text
+    ) external returns (bytes memory) {
+        // non-view dummy portion of the function
+        _dummyCounter++;
+        // read compressed text from chain-state
+        return _text.getCompressed();
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address.
+     *         Non-view variant to easily measure gas costs of large reads.
+     * @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 readTextNonView(
+        uint256 _textSlotId
+    ) external returns (string memory) {
+        // non-view dummy portion of the function
+        _dummyCounter++;
+        // read text from chain-state
+        return
+            BytecodeStorageReader.readFromBytecode(
+                storedTextBytecodeAddresses[_textSlotId]
+            );
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                       Additional Introspection
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @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 BytecodeStorageReader.readFromBytecode(_bytecodeAddress);
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address with an
+     *         explicitly provided `_offset`.
+     * @param _bytecodeAddress address from which to read text content.
+     * @param _offset Offset to read from in contract bytecode,
+     *                explicitly provided (not calculated)
+     * @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 forceReadTextAtAddress(
+        address _bytecodeAddress,
+        uint256 _offset
+    ) public view returns (string memory) {
+        return
+            string(
+                BytecodeStorageReader.readBytesFromBytecode(
+                    _bytecodeAddress,
+                    _offset
+                )
+            );
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address that
+     *         was written with SSTORE2.
+     * @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 readSSTORE2TextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (string memory) {
+        return
+            string(
+                BytecodeStorageReader.readBytesFromSSTORE2Bytecode(
+                    _bytecodeAddress
+                )
+            );
+    }
+
+    /**
+     * @notice Allows introspection of who deployed a given contracts-as-storage
+     *         contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the author address.
+     * @return address of the author who wrote the data contained in the
+     *                 given `_bytecodeAddress` contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readAuthorForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (address) {
+        return
+            BytecodeStorageReader.getWriterAddressForBytecode(_bytecodeAddress);
+    }
+
+    /**
+     * @notice Allows introspection of the version of a given contracts-as-storage
+     *         contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the version.
+     * @return bytes32 version of the version string contained in the given `_bytecodeAddress`
+     *                 contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readLibraryVersionForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (bytes32) {
+        return
+            BytecodeStorageReader.getLibraryVersionForBytecode(
+                _bytecodeAddress
+            );
+    }
+
+    /**
+     * @notice Allows introspection of if stored data are in compressed format of a given
+     *         contracts-as-storage contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the version.
+     * @return bool indicating if data are stored in compressed format in the given
+     *         `_bytecodeAddress` contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readIsCompressedForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (bool) {
+        return
+            BytecodeStorageReader.getIsCompressedForBytecode(_bytecodeAddress);
+    }
+
+    function getCompressed(
+        string memory _text
+    ) public pure returns (bytes memory) {
+        return _text.getCompressed();
+    }
+
+    /**
+     * @notice Allows additional internal purge-logic introspection, by allowing
+     *         for the sending of arbitrary data from this contract to the
+     *         provided existing `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to send call data.
+     * @param _data aribtrary data to send as call-data for raw `.call`.
+     * @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
+     */
+    function callWithNonsenseData(
+        address _bytecodeAddress,
+        bytes memory _data
+    ) external onlyDeployer {
+        (bool success /* `data` not needed */, ) = _bytecodeAddress.call(_data);
+        if (success) {
+            // WARNING - This implementation does not make use of the low-level
+            //           call return result indicating success/failure. This is
+            //           contrary to best practice but is OK in this instance as
+            //           this method IS NOT SECURE AND SHOULD NOT BE USED IN
+            //           PRODUCTION under any normal circumstances.
+        }
+    }
+
+    /**
+     * @notice Allows additional internal purge-logic introspection, by allowing
+     *         for the sending of raw calls (with no data) from this contract to
+     *         the provided existing `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to send call data.
+     * @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
+     */
+    function callWithoutData(address _bytecodeAddress) external onlyDeployer {
+        (bool success /* `data` not needed */, ) = _bytecodeAddress.call("");
+        if (success) {
+            // WARNING - This implementation does not make use of the low-level
+            //           call return result indicating success/failure. This is
+            //           contrary to best practice but is OK in this instance as
+            //           this method IS NOT SECURE AND SHOULD NOT BE USED IN
+            //           PRODUCTION under any normal circumstances.
+        }
+    }
+}

package/contracts/mock/ERC20MockAltDecimals.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin-4.5/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20MockAltDecimals is ERC20 {
+    // add a banned address to enable testing of unsuccessful transfers
+    address public bannedReceiver;
+
+    constructor(uint256 initialSupply) ERC20("Mock Token", "MOCK") {
+        _mint(msg.sender, initialSupply);
+    }
+
+    function updateBannedAddress(address account) external {
+        bannedReceiver = account;
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return 6;
+    }
+
+    function _afterTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        require(to != bannedReceiver, "ERC20Mock: transfer to banned address");
+        super._afterTokenTransfer(from, to, amount);
+    }
+}

package/contracts/mock/ForceSendMock.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.19;
+
+import {SplitFundsLib} from "../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract exposes a payable function that force-sends ETH to a target
+ * address.
+ */
+contract ForceSendMock {
+    // @dev forwards msg.value to target address
+    function forceSendETH(address target) external payable {
+        SplitFundsLib.forceSafeTransferETH({
+            to: target,
+            amount: msg.value,
+            // induce force-send by having a low gas limit
+            minterRefundGasLimit: 1_000
+        });
+    }
+}

package/contracts/mock/Mock0xSplitsV2PullFactory.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+import {Mock0xSplitsV2Splitter} from "./Mock0xSplitsV2Splitter.sol";
+
+import {Create2} from "@openzeppelin-5.0/contracts/utils/Create2.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract implements a mock version of the splitter factory deployed
+ * by 0xSplits V2.
+ * Behaviors are not exactly the same as the production version of the contract
+ * and are implemented for integration and testing purposes.
+ */
+contract Mock0xSplitsV2PullFactory is ISplitFactoryV2 {
+    /**
+     * @notice Create a new split with params and owner.
+     * For testing purposes only.
+     * @dev This function is not implemented exactly like 0xSplits V2 factory, but is
+     * sufficient for testing purposes.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _creator Creator of created split.
+     * @param _salt Salt for create2.
+     * @return split Address of the created split.
+     */
+    function createSplitDeterministic(
+        Split calldata _splitParams,
+        address _owner,
+        address _creator,
+        bytes32 _salt
+    ) external returns (address split) {
+        require(_creator != address(0), "Invalid creator");
+        // deploy + initialize
+        address newSplitter = Create2.deploy({
+            amount: 0,
+            salt: _getFakeMockHash(_splitParams, _owner, _salt),
+            bytecode: type(Mock0xSplitsV2Splitter).creationCode
+        });
+        Mock0xSplitsV2Splitter(newSplitter).initialize(_splitParams, _owner);
+        return newSplitter;
+    }
+
+    /**
+     * @notice Predict the address of a new split and check if it is deployed.
+     * For testing purposes only, namely, this function is not equivalent to the
+     * implementation shipped for 0xSplits V2, and is only for testing purposes.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _salt Salt for create2.
+     */
+    function isDeployed(
+        Split calldata _splitParams,
+        address _owner,
+        bytes32 _salt
+    ) external view returns (address split, bool exists) {
+        address predictedSplitter = Create2.computeAddress({
+            salt: _getFakeMockHash(_splitParams, _owner, _salt),
+            bytecodeHash: keccak256(type(Mock0xSplitsV2Splitter).creationCode)
+        });
+        return (predictedSplitter, predictedSplitter.code.length > 0);
+    }
+
+    // this gets a fack hash with all split and owner params for testing purposes,
+    // and does not match 0xSplits implementation
+    function _getFakeMockHash(
+        Split memory splitParams,
+        address owner,
+        bytes32 salt
+    ) private pure returns (bytes32) {
+        return keccak256(abi.encode(splitParams, owner, salt));
+    }
+}

package/contracts/mock/Mock0xSplitsV2Splitter.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract implements a mock version of a splitter deployed
+ * by 0xSplits V2.
+ * Behaviors are not the same as the production version of the contract
+ * and are implemented for integration and testing purposes.
+ * Notably, this contract is not actually a splitter, but more of an introspection
+ * contract for testing purposes.
+ */
+contract Mock0xSplitsV2Splitter {
+    ISplitFactoryV2.Split private _splitParams;
+    address private _owner;
+    bool private _isInitialized;
+
+    function initialize(
+        ISplitFactoryV2.Split memory splitParams,
+        address owner
+    ) external {
+        _splitParams = splitParams;
+        _owner = owner;
+        _isInitialized = true;
+    }
+
+    function getSplitParams()
+        external
+        view
+        returns (ISplitFactoryV2.Split memory)
+    {
+        _onlyInitialized();
+        return _splitParams;
+    }
+
+    function getOwner() external view returns (address) {
+        _onlyInitialized();
+        return _owner;
+    }
+
+    function _onlyInitialized() private view {
+        require(_isInitialized, "Splitter not initialized");
+    }
+}

package/contracts/mock/MockAdminACLV0.sol

@@ -54,6 +54,27 @@ contract MockAdminACLV0Events is IAdminACLV0, ERC165 {
         Ownable(_contract).transferOwnership(_newAdminACL);
     }
 
+    /**
+     * @notice Allows superAdmin change the superAdmin address.
+     * @param _newSuperAdmin The new superAdmin address.
+     * @param _genArt721CoreAddressesToUpdate Array of genArt721Core
+     * addresses to update to the new superAdmin, for indexing purposes only.
+     * @dev this function is gated to only superAdmin address.
+     */
+    function changeSuperAdmin(
+        address _newSuperAdmin,
+        address[] calldata _genArt721CoreAddressesToUpdate
+    ) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        address previousSuperAdmin = superAdmin;
+        superAdmin = _newSuperAdmin;
+        emit SuperAdminTransferred(
+            previousSuperAdmin,
+            _newSuperAdmin,
+            _genArt721CoreAddressesToUpdate
+        );
+    }
+
     /**
      * @dev Allows superAdmin to call renounceOwnership on other contract from
      * this contract.

package/contracts/mock/MockAdminACLV0_PROHIBITION.sol

@@ -63,6 +63,27 @@ contract MockAdminACLV0Events_PROHIBITION is IAdminACLV0_PROHIBITION, ERC165 {
             contractArtistApprovals[hashArtistApprovalKey(_contract, _caller)];
     }
 
+    /**
+     * @notice Allows superAdmin change the superAdmin address.
+     * @param _newSuperAdmin The new superAdmin address.
+     * @param _genArt721CoreAddressesToUpdate Array of genArt721Core
+     * addresses to update to the new superAdmin, for indexing purposes only.
+     * @dev this function is gated to only superAdmin address.
+     */
+    function changeSuperAdmin(
+        address _newSuperAdmin,
+        address[] calldata _genArt721CoreAddressesToUpdate
+    ) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        address previousSuperAdmin = superAdmin;
+        superAdmin = _newSuperAdmin;
+        emit SuperAdminTransferred(
+            previousSuperAdmin,
+            _newSuperAdmin,
+            _genArt721CoreAddressesToUpdate
+        );
+    }
+
     /**
      * @dev Allows superAdmin to set a contract function caller.
      */