@artblocks/contracts 1.3.2 → 1.4.0

package/contracts/mock/MockTransferHook.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import {AbstractTransferHook} from "../engine/V3/transfer-hooks/AbstractTransferHook.sol";
+import {IGenArt721CoreContractV3_Base} from "../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
+import {IGenArt721CoreContractV3_Engine} from "../interfaces/v0.8.x/IGenArt721CoreContractV3_Engine.sol";
+
+import {IERC721} from "@openzeppelin-5.0/contracts/token/ERC721/IERC721.sol";
+
+/**
+ * @title Mock transfer hook for testing V3 Engine transfer hooks.
+ * @notice Records hook inputs, optionally reverts, and can attempt reentrancy
+ * into transfer / mint / configure / lock on the calling core.
+ * @dev Intentionally does NOT restrict which cores it will serve, so a single
+ * instance can be used across the Engine and Engine Flex test suites.
+ * Production hooks must restrict `coreContract`.
+ */
+contract MockTransferHook is AbstractTransferHook {
+    event TokenTransferred(
+        address indexed coreContract,
+        uint256 indexed tokenId,
+        address from,
+        address to,
+        address operator
+    );
+
+    address public lastCoreContract;
+    uint256 public lastTokenId;
+    address public lastFrom;
+    address public lastTo;
+    address public lastOperator;
+    bytes32 public lastTokenHash;
+    uint256 public callCount;
+
+    bool public shouldRevert;
+    bool public reenterTransfer;
+    bool public reenterConfigure;
+    bool public reenterLock;
+    address public reenterTransferTo;
+
+    /// when set, reentrant transfer targets an explicit token rather than the
+    /// token this hook was invoked for (used to test cross-project blocking)
+    bool public reenterCustomToken;
+    address public reenterCustomFrom;
+    uint256 public reenterCustomTokenId;
+
+    /// when set, the hook attempts to purchase through a minter, which
+    /// reenters the core's mint path
+    bool public reenterPurchase;
+    address public reenterPurchaseMinter;
+    uint256 public reenterPurchaseProjectId;
+
+    function setShouldRevert(bool _shouldRevert) external {
+        shouldRevert = _shouldRevert;
+    }
+
+    function setReenterTransfer(
+        bool _reenterTransfer,
+        address _reenterTransferTo
+    ) external {
+        reenterTransfer = _reenterTransfer;
+        reenterTransferTo = _reenterTransferTo;
+    }
+
+    function setReenterCustomToken(
+        bool _reenterCustomToken,
+        address _reenterCustomFrom,
+        uint256 _reenterCustomTokenId
+    ) external {
+        reenterCustomToken = _reenterCustomToken;
+        reenterCustomFrom = _reenterCustomFrom;
+        reenterCustomTokenId = _reenterCustomTokenId;
+    }
+
+    function setReenterPurchase(
+        bool _reenterPurchase,
+        address _minter,
+        uint256 _projectId
+    ) external {
+        reenterPurchase = _reenterPurchase;
+        reenterPurchaseMinter = _minter;
+        reenterPurchaseProjectId = _projectId;
+    }
+
+    function setReenterConfigure(bool _reenterConfigure) external {
+        reenterConfigure = _reenterConfigure;
+    }
+
+    function setReenterLock(bool _reenterLock) external {
+        reenterLock = _reenterLock;
+    }
+
+    function _onTokenTransfer(
+        address coreContract,
+        uint256 tokenId,
+        address from,
+        address to,
+        address operator
+    ) internal override {
+        lastCoreContract = coreContract;
+        lastTokenId = tokenId;
+        lastFrom = from;
+        lastTo = to;
+        lastOperator = operator;
+        lastTokenHash = IGenArt721CoreContractV3_Base(coreContract)
+            .tokenIdToHash(tokenId);
+        unchecked {
+            callCount++;
+        }
+
+        emit TokenTransferred(coreContract, tokenId, from, to, operator);
+
+        if (shouldRevert) {
+            revert("MockTransferHook: Intentional revert");
+        }
+
+        if (reenterTransfer) {
+            if (reenterCustomToken) {
+                IERC721(coreContract).transferFrom(
+                    reenterCustomFrom,
+                    reenterTransferTo,
+                    reenterCustomTokenId
+                );
+            } else {
+                IERC721(coreContract).transferFrom(
+                    to,
+                    reenterTransferTo,
+                    tokenId
+                );
+            }
+        }
+
+        if (reenterPurchase) {
+            // @dev bubble the revert reason so the core's custom error is
+            // observable by the test, rather than being swallowed here
+            (bool success, bytes memory returnData) = reenterPurchaseMinter
+                .call(
+                    abi.encodeWithSignature(
+                        "purchase(uint256)",
+                        reenterPurchaseProjectId
+                    )
+                );
+            if (!success) {
+                assembly {
+                    revert(add(returnData, 32), mload(returnData))
+                }
+            }
+        }
+
+        if (reenterConfigure) {
+            IGenArt721CoreContractV3_Engine(coreContract)
+                .configureProjectTransferHook(tokenId / 1_000_000, address(0));
+        }
+
+        if (reenterLock) {
+            IGenArt721CoreContractV3_Engine(coreContract)
+                .lockProjectTransferHook(tokenId / 1_000_000, address(this));
+        }
+    }
+}

package/contracts/mock/MockTransferHookTestHelpers.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import {ITransferHook} from "../interfaces/v0.8.x/ITransferHook.sol";
+
+import {IERC721} from "@openzeppelin-5.0/contracts/token/ERC721/IERC721.sol";
+import {IERC721Receiver} from "@openzeppelin-5.0/contracts/token/ERC721/IERC721Receiver.sol";
+
+/**
+ * @title Mock ERC-721 receiver that forwards the token it receives.
+ * @notice Used to verify that a V3 core releases its transfer hook reentrancy
+ * guard before invoking `onERC721Received`, so that escrow/wrapper contracts
+ * which forward on receipt continue to work.
+ */
+contract MockForwardingERC721Receiver is IERC721Receiver {
+    address public forwardTo;
+
+    /**
+     * @param _forwardTo Address to forward received tokens to. If
+     * `address(0)`, received tokens are kept.
+     */
+    function setForwardTo(address _forwardTo) external {
+        forwardTo = _forwardTo;
+    }
+
+    function onERC721Received(
+        address /* operator */,
+        address /* from */,
+        uint256 tokenId,
+        bytes calldata /* data */
+    ) external returns (bytes4) {
+        if (forwardTo != address(0)) {
+            // @dev msg.sender is the core contract performing the safe transfer
+            IERC721(msg.sender).transferFrom(address(this), forwardTo, tokenId);
+        }
+        return IERC721Receiver.onERC721Received.selector;
+    }
+}
+
+/**
+ * @title Mock batch transferrer.
+ * @notice Performs multiple sequential (not nested) transfers in a single
+ * transaction. Used to verify that the transfer hook reentrancy guard is
+ * per-call rather than per-transaction, so marketplace batch flows are
+ * unaffected.
+ */
+contract MockBatchTransferrer {
+    function batchTransfer(
+        address coreContract,
+        address from,
+        address to,
+        uint256[] calldata tokenIds
+    ) external {
+        uint256 length = tokenIds.length;
+        for (uint256 i; i < length; i++) {
+            IERC721(coreContract).transferFrom(from, to, tokenIds[i]);
+        }
+    }
+}
+
+/**
+ * @title Mock core that invokes a transfer hook with arbitrary inputs.
+ * @notice Covers the one caller `AbstractTransferHook` cannot reject: a
+ * contract that passes its own address as `coreContract`. Its answer to
+ * `projectTransferHookConfig` is settable, so both a caller that has not
+ * configured the hook and one that claims it has can be simulated.
+ */
+contract MockSpoofingCore {
+    address public configuredHook;
+
+    function setConfiguredHook(address hook) external {
+        configuredHook = hook;
+    }
+
+    function projectTransferHookConfig(
+        uint256 /* projectId */
+    ) external view returns (address hook, bool locked) {
+        return (configuredHook, false);
+    }
+
+    function callHook(
+        address hook,
+        uint256 tokenId,
+        address from,
+        address to,
+        address operator
+    ) external {
+        ITransferHook(hook).onTokenTransfer({
+            coreContract: address(this),
+            tokenId: tokenId,
+            from: from,
+            to: to,
+            operator: operator
+        });
+    }
+}

package/contracts/mock/ReentrancyBatchMockShared.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+pragma solidity ^0.8.0;
+
+interface IBatchMinter {
+    function purchaseMultiple(
+        uint256 projectId,
+        address coreContract,
+        uint24 quantity
+    ) external payable returns (uint256[] memory tokenIds);
+
+    function purchase(
+        uint256 projectId,
+        address coreContract
+    ) external payable returns (uint256 tokenId);
+}
+
+contract ReentrancyBatchMockShared {
+    uint256 public currentProjectId;
+    address public currentCoreContract;
+    address public currentMinter;
+    uint256 public currentPriceToPay;
+    bool public shouldReenter;
+
+    function attackBatch(
+        address _minterContractAddress,
+        uint256 _projectId,
+        address _coreContract,
+        uint24 _quantity,
+        uint256 _priceToPay
+    ) external payable {
+        currentProjectId = _projectId;
+        currentCoreContract = _coreContract;
+        currentMinter = _minterContractAddress;
+        currentPriceToPay = _priceToPay;
+        shouldReenter = true;
+        IBatchMinter(_minterContractAddress).purchaseMultiple{value: msg.value}(
+            _projectId,
+            _coreContract,
+            _quantity
+        );
+    }
+
+    receive() external payable {
+        if (shouldReenter) {
+            shouldReenter = false;
+            IBatchMinter(currentMinter).purchase{value: currentPriceToPay}(
+                currentProjectId,
+                currentCoreContract
+            );
+        }
+    }
+}

package/contracts/mock/RelayExecutorTestHelper.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import {RelayExecutor} from "../relay/RelayExecutor.sol";
+import {RelayExecutorPartialReverts} from "../relay/RelayExecutorPartialReverts.sol";
+
+/// @dev Helper that wraps RelayExecutor so tests can invoke execute() as
+///      msg.sender == address(this), mimicking the EIP-7702 delegation model
+///      where the EOA calls its own delegated code.
+contract RelayExecutorTestHelper is RelayExecutor {
+    /// @dev Calls execute on this contract from itself so that
+    ///      msg.sender == address(this) and the base ERC7821 auth passes.
+    function selfExecute(bytes32 mode, bytes calldata executionData) external {
+        this.execute(mode, executionData);
+    }
+}
+
+/// @dev Simple target contract for testing batch calls.
+contract MockTarget {
+    uint256 public value;
+    address public lastCaller;
+
+    event Called(uint256 val);
+
+    function setValue(uint256 val) external payable {
+        value = val;
+        lastCaller = msg.sender;
+        emit Called(val);
+    }
+
+    function alwaysReverts() external pure {
+        revert("MockTarget: forced revert");
+    }
+
+    receive() external payable {}
+}
+
+/// @dev Helper that wraps RelayExecutorPartialReverts so tests can invoke
+///      execute() as msg.sender == address(this).
+contract RelayExecutorPartialRevertsTestHelper is RelayExecutorPartialReverts {
+    function selfExecute(bytes32 mode, bytes calldata executionData) external {
+        this.execute(mode, executionData);
+    }
+}

package/contracts/relay/RelayExecutor.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import {ERC7821} from "solady/src/accounts/ERC7821.sol";
+import {ECDSA} from "solady/src/utils/ECDSA.sol";
+
+/// @title RelayExecutor
+/// @notice EIP-7702 delegation target for batched EVM call execution with
+///         per-bundle log delimiting. Extends Solady ERC7821 with a
+///         BundleExecuted event emitted after each sub-batch completes,
+///         enabling reliable log attribution by the relay.
+/// @dev Deploy deterministically via CREATE2 for same address on all chains.
+///      Stateless, no storage, no initialization, no upgrade concerns.
+///
+///      Relay encoding uses the ERC-7821 batch-of-batches mode: each queue
+///      item becomes its own sub-batch. The base _executeBatchOfBatches loops
+///      through sub-batches calling execute() per sub-batch, which flows
+///      through our _execute(Call[]) override and emits BundleExecuted.
+///
+///      Receipt log layout for a batch with 3 bundles:
+///        [logA, logB, BundleExecuted, logC, logD, BundleExecuted, logF, BundleExecuted]
+///         └── bundle 0 ──────────────┘ └── bundle 1 ─────────────┘ └── bundle 2 ────┘
+contract RelayExecutor is ERC7821 {
+    /// @notice Emitted after each bundle (sub-batch) completes successfully.
+    ///         The relay slices receipt logs between consecutive BundleExecuted
+    ///         events to attribute logs to the originating queue item.
+    event BundleExecuted();
+
+    /// @notice ERC-1271 signature validation. Performs ecrecover against the
+    ///         EOA address (address(this) under EIP-7702 delegation).
+    ///         Required because some contracts skip ecrecover when the signer has code.
+    function isValidSignature(
+        bytes32 hash,
+        bytes calldata signature
+    ) public view virtual returns (bytes4 result) {
+        bool success = ECDSA.recoverCalldata(hash, signature) == address(this);
+        /// @solidity memory-safe-assembly
+        assembly {
+            // success ? bytes4(keccak256("isValidSignature(bytes32,bytes)")) : 0xffffffff
+            result := shl(224, or(0x1626ba7e, sub(0, iszero(success))))
+        }
+    }
+
+    /// @notice Execute all calls in a bundle, then emit BundleExecuted.
+    function _execute(
+        Call[] calldata calls,
+        bytes32 extraData
+    ) internal override {
+        unchecked {
+            uint256 n = calls.length;
+            for (uint256 i; i < n; ++i) {
+                (address to, uint256 value, bytes calldata data) = _get(
+                    calls,
+                    i
+                );
+                _execute(to, value, data, extraData);
+            }
+        }
+        emit BundleExecuted();
+    }
+}

package/contracts/relay/RelayExecutorPartialReverts.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import {RelayExecutor} from "./RelayExecutor.sol";
+
+/// @title RelayExecutorPartialReverts
+/// @notice Variant of RelayExecutor where each bundle in a batch-of-batches
+///         executes independently. A failing bundle reverts only its own state
+///         changes; all other bundles continue executing.
+/// @dev Overrides _executeBatchOfBatches to wrap each sub-batch execute() in a
+///      try/catch, creating an isolated EVM call frame per bundle.
+///
+///      Successful bundles emit BundleExecuted (inherited from RelayExecutor).
+///      Failed bundles emit BundleFailed with the revert reason from the
+///      parent frame — the failed bundle's state changes and logs are rolled
+///      back by the EVM.
+///
+///      Receipt log layout for a batch with 3 bundles (bundle 1 fails):
+///        [logA, logB, BundleExecuted, BundleFailed, logF, BundleExecuted]
+///         └── bundle 0 ──────────────┘ └─ bundle 1 ┘ └── bundle 2 ────┘
+contract RelayExecutorPartialReverts is RelayExecutor {
+    /// @notice Emitted when a bundle fails. Serves as a delimiter for the
+    ///         failed bundle (no inner logs since its state was reverted).
+    /// @param bundleIndex Index of the failed bundle within the batch.
+    /// @param reason ABI-encoded revert reason from the failed sub-call.
+    event BundleFailed(uint256 bundleIndex, bytes reason);
+
+    /// @dev Overrides ERC7821._executeBatchOfBatches to isolate each sub-batch
+    ///      in its own call frame via try/catch on an external self-call.
+    ///      The self-call sets msg.sender = address(this) in the child frame,
+    ///      so we must enforce auth here to prevent unauthorized callers from
+    ///      bypassing the check that normally happens inside _execute.
+    function _executeBatchOfBatches(
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal override {
+        require(msg.sender == address(this));
+        // Convert mode from batch-of-batches (0x78210002) to single-batch
+        // with opData support (0x78210001), same as the base implementation.
+        mode ^= bytes32(uint256(3 << (22 * 8)));
+        (uint256 n, uint256 o, uint256 e) = (0, 0, 0);
+        /// @solidity memory-safe-assembly
+        assembly {
+            let j := calldataload(executionData.offset)
+            let t := add(executionData.offset, j)
+            n := calldataload(t)
+            o := add(0x20, t)
+            e := add(executionData.offset, executionData.length)
+            if or(
+                shr(64, j),
+                or(lt(executionData.length, 0x20), gt(add(o, shl(5, n)), e))
+            ) {
+                mstore(0x00, 0x3995943b) // `BatchOfBatchesDecodingError()`.
+                revert(0x1c, 0x04)
+            }
+        }
+        unchecked {
+            for (uint256 i; i != n; ++i) {
+                bytes calldata batch;
+                /// @solidity memory-safe-assembly
+                assembly {
+                    let j := calldataload(add(o, shl(5, i)))
+                    let t := add(o, j)
+                    batch.offset := add(t, 0x20)
+                    batch.length := calldataload(t)
+                    if or(shr(64, j), gt(add(batch.offset, batch.length), e)) {
+                        mstore(0x00, 0x3995943b) // `BatchOfBatchesDecodingError()`.
+                        revert(0x1c, 0x04)
+                    }
+                }
+                // External self-call creates an isolated call frame.
+                // msg.sender == address(this) satisfies the base ERC7821 auth.
+                try this.execute(mode, batch) {} catch (bytes memory reason) {
+                    emit BundleFailed(i, reason);
+                }
+            }
+        }
+    }
+}

package/contracts/royalty-registry/GenArt721RoyaltyOverrideSplits.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {ABHelpers} from "../libs/v0.8.x/ABHelpers.sol";
+import {IArtblocksRoyaltyOverride} from "../interfaces/v0.8.x/IArtblocksRoyaltyOverride.sol";
+
+import {Ownable} from "@openzeppelin-5.0/contracts/access/Ownable.sol";
+import {ERC165, IERC165} from "@openzeppelin-5.0/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title GenArt721RoyaltyOverrideSplits
+ * @author Art Blocks Inc.
+ * @notice Royalty Registry override contract that maps each
+ * (core contract, project) pair to a royalty configuration consisting of
+ * a splitter address and a BPS value. All configuration is managed by a
+ * single owner.
+ */
+contract GenArt721RoyaltyOverrideSplits is
+    ERC165,
+    IArtblocksRoyaltyOverride,
+    Ownable
+{
+    using ABHelpers for uint256;
+
+    uint16 public constant MAX_BPS = 10000;
+
+    /**
+     * @notice Royalty configuration for a single project.
+     * @dev Packed into a single storage slot (20 + 2 = 22 bytes).
+     * @param splitter Address of the royalty splitter contract.
+     * @param bps Royalty basis points (0–10000).
+     */
+    struct RoyaltyConfig {
+        address splitter;
+        uint16 bps;
+    }
+
+    /**
+     * @notice Royalty configuration for a project has been updated.
+     * @dev A splitter of address(0) with bps of 0 indicates the project
+     * has been unconfigured.
+     */
+    event RoyaltyConfigUpdated(
+        address indexed coreContract,
+        uint256 indexed projectId,
+        address splitter,
+        uint16 bps
+    );
+
+    /// core contract => project ID => royalty configuration
+    mapping(address coreContract => mapping(uint256 projectId => RoyaltyConfig config))
+        public royaltyConfigs;
+
+    constructor(address owner_) Ownable(owner_) {}
+
+    /**
+     * @notice Sets the royalty configuration for a given core contract and
+     * project.
+     * @param coreContract Core contract address.
+     * @param projectId Project ID on the core contract.
+     * @param splitter Address of the royalty splitter contract. Must not be
+     * the zero address.
+     * @param bps Royalty basis points (0–10000).
+     */
+    function setRoyaltyConfig(
+        address coreContract,
+        uint256 projectId,
+        address splitter,
+        uint16 bps
+    ) external onlyOwner {
+        require(splitter != address(0), "Must not be zero address");
+        require(bps <= MAX_BPS, "Exceeds max BPS");
+        royaltyConfigs[coreContract][projectId] = RoyaltyConfig(splitter, bps);
+        emit RoyaltyConfigUpdated(coreContract, projectId, splitter, bps);
+    }
+
+    /**
+     * @notice Removes the royalty configuration for a given core contract and
+     * project.
+     * @param coreContract Core contract address.
+     * @param projectId Project ID on the core contract.
+     */
+    function removeRoyaltyConfig(
+        address coreContract,
+        uint256 projectId
+    ) external onlyOwner {
+        delete royaltyConfigs[coreContract][projectId];
+        emit RoyaltyConfigUpdated(coreContract, projectId, address(0), 0);
+    }
+
+    /**
+     * @notice Gets royalties for token `tokenId` on contract `tokenAddress`.
+     * Returns the configured splitter as the sole recipient with the
+     * configured BPS. Reverts if no splitter is configured, causing the
+     * Royalty Registry to fall through to other lookup methods.
+     * @param tokenAddress Token contract to be queried.
+     * @param tokenId Token ID to be queried.
+     * @return recipients_ Single-element array with the splitter address.
+     * @return bps Single-element array with the configured BPS value.
+     */
+    function getRoyalties(
+        address tokenAddress,
+        uint256 tokenId
+    )
+        external
+        view
+        returns (address payable[] memory recipients_, uint256[] memory bps)
+    {
+        uint256 projectId = tokenId.tokenIdToProjectId();
+        RoyaltyConfig storage config = royaltyConfigs[tokenAddress][projectId];
+        require(config.splitter != address(0), "No royalty configured");
+        recipients_ = new address payable[](1);
+        bps = new uint256[](1);
+        recipients_[0] = payable(config.splitter);
+        bps[0] = config.bps;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            interfaceId == type(IArtblocksRoyaltyOverride).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+}