@artblocks/contracts 0.0.1

package/contracts/mock/MockAdminACLV0.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "../interfaces/0.8.x/IAdminACLV0.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 is IAdminACLV0, 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";
+
+    // superAdmin is the only address that passes any and all ACL checks
+    address public superAdmin;
+
+    constructor() {
+        superAdmin = msg.sender;
+    }
+
+    /**
+     * @dev Returns true for all ACL checks.
+     * Also emits event for testing purposes.
+     */
+    function allowed(
+        address _sender,
+        address /*_contract*/,
+        bytes4 _selector
+    ) external returns (bool) {
+        emit ACLCheck(_sender, _selector);
+        return superAdmin == _sender;
+    }
+
+    /**
+     * @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/RandomizerV2_NoAssignMock.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity 0.8.17;
+
+import "../BasicRandomizerV2.sol";
+
+/// @title RandomizerV2_NoAssignMock
+/// @notice WARNING - This is a mock contract. Do not use it in production.
+/// @dev This is a mock of the RandomizerV2 contract that does not assign the
+/// token hash on the core contract at the time of mint.
+/// Instead, anyone may set an existing token's hash via the
+/// `actuallyAssignTokenHash` function.
+contract RandomizerV2_NoAssignMock is BasicRandomizerV2 {
+    // When `genArt721Core` calls this, the call is ignored and nothing is set
+    // on the core contract. Used for test purposes only.
+    function assignTokenHash(uint256 /*_tokenId*/) external pure override {}
+
+    // When ANYONE calls this, token `_tokenId`'s hash is set
+    // 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
+            )
+        );
+        genArt721Core.setTokenHash_8PT(_tokenId, hash);
+    }
+
+    // When ANYONE calls this, token `_tokenId`'s hash is attempted to be set
+    // to zero on the core contract. Used for test purposes only.
+    // @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
+    function actuallyAssignZeroTokenHash(uint256 _tokenId) external {
+        bytes32 hash;
+        genArt721Core.setTokenHash_8PT(_tokenId, hash);
+    }
+}

package/contracts/mock/ReentrancyHolderMock.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/0.8.x/IFilteredMinterHolderV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyHolderMock {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    uint256 public currentPriceToPay;
+    address public currentOwnedNftAddress;
+    uint256 public currentOwnedNftTokenId;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite's Token Holder minter.
+        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 _ownedNftAddress,
+        uint256 _ownedNftTokenId
+    ) external payable {
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentPriceToPay = _priceToPay;
+        currentOwnedNftAddress = _ownedNftAddress;
+        currentOwnedNftTokenId = _ownedNftTokenId;
+        IFilteredMinterHolderV0(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _ownedNftAddress, _ownedNftTokenId);
+    }
+
+    // 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!
+            IFilteredMinterHolderV0(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, currentOwnedNftAddress, currentOwnedNftTokenId);
+        }
+    }
+}

package/contracts/mock/ReentrancyMerkleMock.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/0.8.x/IFilteredMinterMerkleV0.sol";
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This contract is tailored to attack our Merkle allowlist minter with a
+ * reentrency attack. It simulates the case where an artist allowlists a
+ * malicious contract.
+ * @dev Note that a simple contract like this assumes a specific Merkle proof
+ * depth. In this case, a Merkle proof depth of 3 is assumed (since it
+ * integrates well with our tests). More complex strategies could be used to
+ * write a more flexible reentrency attack contract, but it doesn't add more
+ * value to our test suite at this time.
+ */
+contract ReentrancyMerkleMock {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    uint256 public currentPriceToPay;
+    bytes32[3] currentProof;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite's Merkle minter (originally designed for V0). 
+        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,
+        bytes32[] memory _proof
+    ) external payable {
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentPriceToPay = _priceToPay;
+        currentProof[0] = _proof[0];
+        currentProof[1] = _proof[1];
+        currentProof[2] = _proof[2];
+        IFilteredMinterMerkleV0(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _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!
+            IFilteredMinterMerkleV0(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, _proof);
+        }
+    }
+}

package/contracts/mock/ReentrancyMock.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/0.8.x/IFilteredMinterV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyMock {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    uint256 public currentPriceToPay;
+
+    /**
+        @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
+    ) external payable {
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentPriceToPay = _priceToPay;
+        IFilteredMinterV0(_minterContractAddress).purchase{value: _priceToPay}(
+            _projectId
+        );
+    }
+
+    // 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!
+            IFilteredMinterV0(msg.sender).purchase{value: currentPriceToPay}(
+                currentProjectId
+            );
+        }
+    }
+}

package/contracts/royalty-registry/GenArt721RoyaltyOverride.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/0.8.x/IArtblocksRoyaltyOverride.sol";
+import "../interfaces/0.8.x/IGenArt721CoreContractV3.sol";
+
+import "@openzeppelin-4.5/contracts/utils/introspection/ERC165.sol";
+
+pragma solidity 0.8.9;
+
+/**
+ * @title Royalty Registry override for Art Blocks token contracts.
+ * @author Art Blocks Inc.
+ */
+contract GenArt721RoyaltyOverride is ERC165, IArtblocksRoyaltyOverride {
+    /**
+     * @notice Art Blocks royalty payment address for `contractAddress`
+     * updated to be `artblocksRoyaltyAddress`.
+     */
+    event ArtblocksRoyaltyAddressForContractUpdated(
+        address indexed contractAddress,
+        address payable indexed artblocksRoyaltyAddress
+    );
+
+    /**
+     * @notice Art Blocks royalty payment basis points for `tokenAddress`
+     * updated to be `bps` if `useOverride`, else updated to use default
+     * BPS.
+     */
+    event ArtblocksBpsForContractUpdated(
+        address indexed tokenAddress,
+        bool indexed useOverride,
+        uint256 bps
+    );
+
+    /// token contract => Art Blocks royalty payment address
+    mapping(address => address payable)
+        public tokenAddressToArtblocksRoyaltyAddress;
+
+    struct BpsOverride {
+        bool useOverride;
+        uint256 bps;
+    }
+
+    /// Default Art Blocks royalty basis points if no BPS override is set.
+    uint256 public constant ARTBLOCKS_DEFAULT_BPS = 250; // 2.5 percent
+    /// token contract => if bps override is set, and bps value.
+    mapping(address => BpsOverride) public tokenAddressToArtblocksBpsOverride;
+
+    modifier onlyAdminOnContract(address _tokenContract) {
+        require(
+            IGenArt721CoreContractV3(_tokenContract).admin() == msg.sender,
+            "Only core admin for specified token contract"
+        );
+        _;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            // register interface 0x9ca7dc7a - getRoyalties(address,uint256)
+            interfaceId == type(IArtblocksRoyaltyOverride).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @notice Updates Art Blocks royalty payment address for `_tokenContract`
+     * to be `_artblocksRoyaltyAddress`.
+     * @param _tokenContract Token contract to be updated.
+     * @param _artblocksRoyaltyAddress Address to receive royalty payments.
+     */
+    function updateArtblocksRoyaltyAddressForContract(
+        address _tokenContract,
+        address payable _artblocksRoyaltyAddress
+    ) external onlyAdminOnContract(_tokenContract) {
+        tokenAddressToArtblocksRoyaltyAddress[
+            _tokenContract
+        ] = _artblocksRoyaltyAddress;
+        emit ArtblocksRoyaltyAddressForContractUpdated(
+            _tokenContract,
+            _artblocksRoyaltyAddress
+        );
+    }
+
+    /**
+     * @notice Updates Art Blocks royalty payment BPS for `_tokenContract` to be
+     * `_bps`.
+     * @param _tokenContract Token contract to be updated.
+     * @param _bps Art Blocks royalty basis points.
+     * @dev `_bps` must be less than or equal to default bps
+     */
+    function updateArtblocksBpsForContract(
+        address _tokenContract,
+        uint256 _bps
+    ) external onlyAdminOnContract(_tokenContract) {
+        require(
+            _bps <= ARTBLOCKS_DEFAULT_BPS,
+            "override bps for contract must be less than or equal to default"
+        );
+        tokenAddressToArtblocksBpsOverride[_tokenContract] = BpsOverride(
+            true,
+            _bps
+        );
+        emit ArtblocksBpsForContractUpdated(_tokenContract, true, _bps);
+    }
+
+    /**
+     * @notice Clears any overrides of Art Blocks royalty payment BPS for
+     *  `_tokenContract`.
+     * @param _tokenContract Token contract to be cleared.
+     * @dev token contracts without overrides use default BPS value.
+     */
+    function clearArtblocksBpsForContract(
+        address _tokenContract
+    ) external onlyAdminOnContract(_tokenContract) {
+        tokenAddressToArtblocksBpsOverride[_tokenContract] = BpsOverride(
+            false,
+            0
+        ); // initial values
+        emit ArtblocksBpsForContractUpdated(_tokenContract, false, 0);
+    }
+
+    /**
+     * @notice Gets royalites of token ID `_tokenId` on token contract
+     * `_tokenAddress`.
+     * @param _tokenAddress Token contract to be queried.
+     * @param _tokenId Token ID to be queried.
+     * @return recipients_ array of royalty recipients
+     * @return bps array of basis points for each recipient, aligned by index
+     */
+    function getRoyalties(
+        address _tokenAddress,
+        uint256 _tokenId
+    )
+        external
+        view
+        returns (address payable[] memory recipients_, uint256[] memory bps)
+    {
+        recipients_ = new address payable[](3);
+        bps = new uint256[](3);
+        // get standard royalty data for artist and additional payee
+        (
+            address artistAddress,
+            address additionalPayee,
+            uint256 additionalPayeePercentage,
+            uint256 royaltyFeeByID
+        ) = IGenArt721CoreContractV3(_tokenAddress).getRoyaltyData(_tokenId);
+        // translate to desired output
+        recipients_[0] = payable(artistAddress);
+        bps[0] = (uint256(100) - additionalPayeePercentage) * royaltyFeeByID;
+        recipients_[1] = payable(additionalPayee);
+        bps[1] = additionalPayeePercentage * royaltyFeeByID;
+        // append art blocks royalty
+        require(
+            tokenAddressToArtblocksRoyaltyAddress[_tokenAddress] != address(0),
+            "Art Blocks royalty address must be defined for contract"
+        );
+        recipients_[2] = tokenAddressToArtblocksRoyaltyAddress[_tokenAddress];
+        bps[2] = tokenAddressToArtblocksBpsOverride[_tokenAddress].useOverride
+            ? tokenAddressToArtblocksBpsOverride[_tokenAddress].bps
+            : ARTBLOCKS_DEFAULT_BPS;
+        return (recipients_, bps);
+    }
+}

package/contracts/royalty-registry/GenArt721RoyaltyOverride_PBAB.sol

@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/0.8.x/IArtblocksRoyaltyOverride.sol";
+import "../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
+
+import "@openzeppelin-4.5/contracts/utils/introspection/ERC165.sol";
+
+pragma solidity 0.8.9;
+
+/**
+ * @title Royalty Registry override for Art Blocks PBAB token contracts.
+ * @author Art Blocks Inc.
+ */
+contract GenArt721RoyaltyOverride_PBAB is ERC165, IArtblocksRoyaltyOverride {
+    /**
+     * @notice Platform royalty payment address for `contractAddress`
+     * updated to be `platformRoyaltyAddress`.
+     */
+    event PlatformRoyaltyAddressForContractUpdated(
+        address indexed contractAddress,
+        address payable indexed platformRoyaltyAddress
+    );
+
+    /**
+     * @notice Render provider royalty payment basis points for `tokenAddress`
+     * updated to be `bps` if `useOverride`, else updated to use default BPS.
+     */
+    event RenderProviderBpsForContractUpdated(
+        address indexed tokenAddress,
+        bool indexed useOverride,
+        uint256 bps
+    );
+
+    /**
+     * @notice Platform royalty payment basis points for
+     * `tokenAddress` updated to be `bps` if `useOverride`, else
+     * updated to use default BPS.
+     */
+    event PlatformBpsForContractUpdated(
+        address indexed tokenAddress,
+        bool indexed useOverride,
+        uint256 bps
+    );
+
+    /// token contract => Platform royalty payment address
+    mapping(address => address payable)
+        public tokenAddressToPlatformRoyaltyAddress;
+
+    struct BpsOverride {
+        bool useOverride;
+        uint256 bps;
+    }
+
+    /// Default Render Provider royalty basis points if no BPS override is set.
+    uint256 public constant RENDER_PROVIDER_DEFAULT_BPS = 250; // 2.5 percent
+    /// Default Platform royalty basis points if no BPS override is set.
+    uint256 public constant PLATFORM_DEFAULT_BPS = 250; // 2.5 percent
+    /// token contract => if render provider bps override is set, and bps value.
+    mapping(address => BpsOverride)
+        public tokenAddressToRenderProviderBpsOverride;
+    /// token contract => if Platform bps override is set, and bps value.
+    mapping(address => BpsOverride) public tokenAddressToPlatformBpsOverride;
+
+    modifier onlyAdminOnContract(address _tokenContract) {
+        require(
+            IGenArt721CoreV2_PBAB(_tokenContract).admin() == msg.sender,
+            "Only core admin for specified token contract"
+        );
+        _;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            // register interface 0x9ca7dc7a - getRoyalties(address,uint256)
+            interfaceId == type(IArtblocksRoyaltyOverride).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @notice Updates platform royalty payment address for `_tokenContract`
+     * to be `_platformRoyaltyAddress`.
+     * @param _tokenContract Token contract to be updated.
+     * @param _platformRoyaltyAddress Address to receive royalty payments.
+     */
+    function updatePlatformRoyaltyAddressForContract(
+        address _tokenContract,
+        address payable _platformRoyaltyAddress
+    ) external onlyAdminOnContract(_tokenContract) {
+        tokenAddressToPlatformRoyaltyAddress[
+            _tokenContract
+        ] = _platformRoyaltyAddress;
+        emit PlatformRoyaltyAddressForContractUpdated(
+            _tokenContract,
+            _platformRoyaltyAddress
+        );
+    }
+
+    /**
+     * @notice Updates render provider royalty payment BPS for `_tokenContract`
+     * to be `_bps`.
+     * @param _tokenContract Token contract to be updated.
+     * @param _bps Render provider royalty payment basis points.
+     */
+    function updateRenderProviderBpsForContract(
+        address _tokenContract,
+        uint256 _bps
+    ) external onlyAdminOnContract(_tokenContract) {
+        require(_bps <= 10000, "invalid bps");
+        tokenAddressToRenderProviderBpsOverride[_tokenContract] = BpsOverride(
+            true,
+            _bps
+        );
+        emit RenderProviderBpsForContractUpdated(_tokenContract, true, _bps);
+    }
+
+    /**
+     * @notice Updates platform royalty payment BPS for `_tokenContract` to be
+     * `_bps`.
+     * @param _tokenContract Token contract to be updated.
+     * @param _bps Platform royalty payment basis points.
+     */
+    function updatePlatformBpsForContract(
+        address _tokenContract,
+        uint256 _bps
+    ) external onlyAdminOnContract(_tokenContract) {
+        require(_bps <= 10000, "invalid bps");
+        tokenAddressToPlatformBpsOverride[_tokenContract] = BpsOverride(
+            true,
+            _bps
+        );
+        emit PlatformBpsForContractUpdated(_tokenContract, true, _bps);
+    }
+
+    /**
+     * @notice Clears any overrides of render provider royalty payment BPS
+     * for `_tokenContract`.
+     * @param _tokenContract Token contract to be cleared.
+     * @dev token contracts without overrides use default BPS value.
+     */
+    function clearRenderProviderBpsForContract(
+        address _tokenContract
+    ) external onlyAdminOnContract(_tokenContract) {
+        tokenAddressToRenderProviderBpsOverride[_tokenContract] = BpsOverride(
+            false,
+            0
+        ); // initial values
+        emit RenderProviderBpsForContractUpdated(_tokenContract, false, 0);
+    }
+
+    /**
+     * @notice Clears any overrides of platform provider royalty payment BPS
+     * for `_tokenContract`.
+     * @param _tokenContract Token contract to be cleared.
+     * @dev token contracts without overrides use default BPS value.
+     */
+    function clearPlatformBpsForContract(
+        address _tokenContract
+    ) external onlyAdminOnContract(_tokenContract) {
+        tokenAddressToPlatformBpsOverride[_tokenContract] = BpsOverride(
+            false,
+            0
+        ); // initial values
+        emit PlatformBpsForContractUpdated(_tokenContract, false, 0);
+    }
+
+    /**
+     * @notice Gets royalites of token ID `_tokenId` on token contract
+     * `_tokenAddress`.
+     * @param _tokenAddress Token contract to be queried.
+     * @param _tokenId Token ID to be queried.
+     * @return recipients_ array of royalty recipients
+     * @return bps array of basis points for each recipient, aligned by index
+     */
+    function getRoyalties(
+        address _tokenAddress,
+        uint256 _tokenId
+    )
+        external
+        view
+        returns (address payable[] memory recipients_, uint256[] memory bps)
+    {
+        recipients_ = new address payable[](4);
+        bps = new uint256[](4);
+        // get standard royalty data for artist and additional payee
+        (
+            address artistAddress,
+            address additionalPayee,
+            uint256 additionalPayeePercentage,
+            uint256 royaltyFeeByID
+        ) = IGenArt721CoreV2_PBAB(_tokenAddress).getRoyaltyData(_tokenId);
+        // translate to desired output
+        recipients_[0] = payable(artistAddress);
+        bps[0] = (uint256(100) - additionalPayeePercentage) * royaltyFeeByID;
+        recipients_[1] = payable(additionalPayee);
+        bps[1] = additionalPayeePercentage * royaltyFeeByID;
+        // append platform provider royalty
+        require(
+            tokenAddressToPlatformRoyaltyAddress[_tokenAddress] != address(0),
+            "Platform royalty address must be defined for contract"
+        );
+        recipients_[2] = tokenAddressToPlatformRoyaltyAddress[_tokenAddress];
+        bps[2] = tokenAddressToPlatformBpsOverride[_tokenAddress].useOverride
+            ? tokenAddressToPlatformBpsOverride[_tokenAddress].bps
+            : PLATFORM_DEFAULT_BPS;
+        // append render provider royalty
+        recipients_[3] = payable(
+            IGenArt721CoreV2_PBAB(_tokenAddress).renderProviderAddress()
+        );
+        bps[3] = tokenAddressToRenderProviderBpsOverride[_tokenAddress]
+            .useOverride
+            ? tokenAddressToRenderProviderBpsOverride[_tokenAddress].bps
+            : RENDER_PROVIDER_DEFAULT_BPS;
+        return (recipients_, bps);
+    }
+}