@artblocks/contracts 1.2.0 → 1.3.0

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/ImmutableStringArrayMock.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ImmutableStringArray} from "../libs/v0.8.x/ImmutableStringArray.sol";
+
+/**
+ * @title ImmutableStringArrayMock
+ * @notice Mock contract for testing ImmutableStringArray library functionality
+ */
+contract ImmutableStringArrayMock {
+    using ImmutableStringArray for ImmutableStringArray.StringArray;
+
+    ImmutableStringArray.StringArray private stringArray;
+
+    /**
+     * @notice Store an array of strings
+     * @param strings The array of strings to store
+     */
+    function store(string[] memory strings) external {
+        stringArray.store(strings);
+    }
+
+    /**
+     * @notice Get the length of the stored array
+     * @return The number of strings stored
+     */
+    function length() external view returns (uint256) {
+        return stringArray.length();
+    }
+
+    /**
+     * @notice Get a string at a specific index
+     * @param index The index to retrieve
+     * @return The string at the given index
+     */
+    function get(uint256 index) external view returns (string memory) {
+        return stringArray.get(index);
+    }
+
+    /**
+     * @notice Get all stored strings
+     * @return An array containing all stored strings
+     */
+    function getAll() external view returns (string[] memory) {
+        return stringArray.getAll();
+    }
+}

package/contracts/mock/MockFileStore.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {IScriptyContractStorage} from "scripty.sol/contracts/scripty/interfaces/IScriptyContractStorage.sol";
+
+contract MockFileStore is IScriptyContractStorage {
+    string constant GUNZIP_SCRIPT_NAME = "gunzipScripts-0.0.1.js";
+
+    function getContent(
+        string calldata name,
+        bytes memory
+    ) external pure returns (bytes memory script) {
+        if (
+            keccak256(abi.encodePacked(name)) ==
+            keccak256(abi.encodePacked(GUNZIP_SCRIPT_NAME))
+        ) {
+            return
+                "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";
+        }
+        return abi.encodePacked(name);
+    }
+}

package/contracts/mock/MockPMPAugmentHook.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/IPMPAugmentHook.sol";
+import "../interfaces/v0.8.x/IWeb3Call.sol";
+import "@openzeppelin-5.0/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title Mock PMP Augment Hook
+ * @notice Mock implementation of IPMPAugmentHook for testing purposes
+ */
+contract MockPMPAugmentHook is IPMPAugmentHook, ERC165 {
+    // Event to track when the hook is called
+    event TokenPMPAugmented(
+        address indexed coreContract,
+        uint256 indexed tokenId,
+        uint256 paramCount
+    );
+
+    // Return behavior settings
+    bool public shouldAddParam = false;
+    bool public shouldModifyParams = false;
+    bool public shouldRevert = false;
+
+    // Parameters for augmentation
+    string public augmentKey = "augmentedParam";
+    string public augmentValue = "augmentedValue";
+
+    /**
+     * @notice Configure the hook behavior
+     * @param _shouldAddParam Whether the hook should add a parameter
+     * @param _shouldModifyParams Whether the hook should modify existing parameters
+     * @param _shouldRevert Whether the hook should revert
+     */
+    function setHookBehavior(
+        bool _shouldAddParam,
+        bool _shouldModifyParams,
+        bool _shouldRevert
+    ) external {
+        shouldAddParam = _shouldAddParam;
+        shouldModifyParams = _shouldModifyParams;
+        shouldRevert = _shouldRevert;
+    }
+
+    /**
+     * @notice Set the augmentation values
+     * @param _augmentKey The key for the augmented parameter
+     * @param _augmentValue The value for the augmented parameter
+     */
+    function setAugmentValues(
+        string memory _augmentKey,
+        string memory _augmentValue
+    ) external {
+        augmentKey = _augmentKey;
+        augmentValue = _augmentValue;
+    }
+
+    /**
+     * @notice Implement the hook method that gets called during token PMP reads
+     * @param tokenParams The original token parameters
+     * @return The augmented token parameters
+     */
+    function onTokenPMPReadAugmentation(
+        address /* coreContract */,
+        uint256 /* tokenId */,
+        IWeb3Call.TokenParam[] calldata tokenParams
+    ) external view override returns (IWeb3Call.TokenParam[] memory) {
+        // Since this is a view function, we can't emit events or modify state
+        // Tests will need to call the hook and then separately call simulateCall
+
+        // Optionally revert to test error handling
+        if (shouldRevert) {
+            revert("MockPMPAugmentHook: Intentional revert");
+        }
+
+        // If we shouldn't modify, just return the original
+        if (!shouldAddParam && !shouldModifyParams) {
+            IWeb3Call.TokenParam[] memory result_ = new IWeb3Call.TokenParam[](
+                tokenParams.length
+            );
+            for (uint256 i = 0; i < tokenParams.length; i++) {
+                result_[i] = tokenParams[i];
+            }
+            return result_;
+        }
+
+        // Handle parameter modification
+        if (shouldModifyParams && tokenParams.length > 0) {
+            // Create a copy to modify
+            IWeb3Call.TokenParam[]
+                memory modifiedParams = new IWeb3Call.TokenParam[](
+                    tokenParams.length
+                );
+
+            // Copy all parameters
+            for (uint256 i = 0; i < tokenParams.length; i++) {
+                modifiedParams[i] = tokenParams[i];
+            }
+
+            // Modify first parameter
+            if (tokenParams.length > 0) {
+                modifiedParams[0].value = string(
+                    abi.encodePacked("modified_", tokenParams[0].value)
+                );
+            }
+
+            // Handle parameter addition if needed
+            if (shouldAddParam) {
+                // Create new array with one additional element
+                IWeb3Call.TokenParam[]
+                    memory augmentedParams = new IWeb3Call.TokenParam[](
+                        modifiedParams.length + 1
+                    );
+
+                // Copy existing modified parameters
+                for (uint256 i = 0; i < modifiedParams.length; i++) {
+                    augmentedParams[i] = modifiedParams[i];
+                }
+
+                // Add new parameter
+                augmentedParams[modifiedParams.length] = IWeb3Call.TokenParam({
+                    key: augmentKey,
+                    value: augmentValue
+                });
+
+                return augmentedParams;
+            }
+
+            return modifiedParams;
+        }
+
+        // Handle parameter addition only
+        if (shouldAddParam) {
+            // Create new array with one additional element
+            IWeb3Call.TokenParam[]
+                memory augmentedParams = new IWeb3Call.TokenParam[](
+                    tokenParams.length + 1
+                );
+
+            // Copy existing parameters
+            for (uint256 i = 0; i < tokenParams.length; i++) {
+                augmentedParams[i] = tokenParams[i];
+            }
+
+            // Add new parameter
+            augmentedParams[tokenParams.length] = IWeb3Call.TokenParam({
+                key: augmentKey,
+                value: augmentValue
+            });
+
+            return augmentedParams;
+        }
+
+        // This should never be reached due to the if checks above
+        revert("MockPMPAugmentHook: Unexpected behavior");
+    }
+
+    /**
+     * @notice Implement ERC165 interface detection
+     * @param interfaceId The interface ID to check
+     * @return True if the interface is supported
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            interfaceId == type(IPMPAugmentHook).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+}

package/contracts/mock/MockPMPConfigureHook.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/IPMPConfigureHook.sol";
+import {IPMPV0} from "../interfaces/v0.8.x/IPMPV0.sol";
+import "@openzeppelin-5.0/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title Mock PMP Configure Hook
+ * @notice Mock implementation of IPMPConfigureHook for testing purposes
+ */
+contract MockPMPConfigureHook is IPMPConfigureHook, ERC165 {
+    // Event to track when the hook is called
+    event TokenPMPConfigured(
+        address indexed coreContract,
+        uint256 indexed tokenId,
+        IPMPV0.PMPInput pmpInput
+    );
+
+    // Track last interaction for testing purposes
+    address public lastCoreContract;
+    uint256 public lastTokenId;
+    string public lastPmpKey;
+    bytes32 public lastConfiguredValue;
+    string public lastConfiguredValueString;
+    bool public lastConfiguringArtistString;
+
+    // Support flag - can be set to simulate failure scenarios
+    bool public shouldRevert = false;
+
+    /**
+     * @notice Sets whether the hook should revert on calls
+     * @param _shouldRevert True if the hook should revert when called
+     */
+    function setShouldRevert(bool _shouldRevert) external {
+        shouldRevert = _shouldRevert;
+    }
+
+    /**
+     * @notice Implement the hook method that gets called after token PMP configuration
+     * @param coreContract The address of the core contract
+     * @param tokenId The token ID that was configured
+     * @param pmpInput The PMP input that was used for configuration
+     */
+    function onTokenPMPConfigure(
+        address coreContract,
+        uint256 tokenId,
+        IPMPV0.PMPInput memory pmpInput
+    ) external override {
+        // Store the information for testing
+        lastCoreContract = coreContract;
+        lastTokenId = tokenId;
+        lastPmpKey = pmpInput.key;
+        lastConfiguredValue = pmpInput.configuredValue;
+        lastConfiguredValueString = pmpInput.configuredValueString;
+        lastConfiguringArtistString = pmpInput.configuringArtistString;
+
+        emit TokenPMPConfigured(coreContract, tokenId, pmpInput);
+
+        // Optionally revert to test error handling
+        if (shouldRevert) {
+            revert("MockPMPConfigureHook: Intentional revert");
+        }
+    }
+
+    /**
+     * @notice Implement ERC165 interface detection
+     * @param interfaceId The interface ID to check
+     * @return True if the interface is supported
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            interfaceId == type(IPMPConfigureHook).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+}