@artblocks/contracts 1.2.0 → 1.3.0

package/artifacts/contracts/web3call/configure-hooks/abstractPMPConfigureHook.sol/AbstractPMPConfigureHook.json

@@ -0,0 +1,80 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "AbstractPMPConfigureHook",
+  "sourceName": "contracts/web3call/configure-hooks/abstractPMPConfigureHook.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "coreContract",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
+        },
+        {
+          "components": [
+            {
+              "internalType": "string",
+              "name": "key",
+              "type": "string"
+            },
+            {
+              "internalType": "enum IPMPV0.ParamType",
+              "name": "configuredParamType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "configuredValue",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bool",
+              "name": "configuringArtistString",
+              "type": "bool"
+            },
+            {
+              "internalType": "string",
+              "name": "configuredValueString",
+              "type": "string"
+            }
+          ],
+          "internalType": "struct IPMPV0.PMPInput",
+          "name": "pmpInput",
+          "type": "tuple"
+        }
+      ],
+      "name": "onTokenPMPConfigure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "interfaceId",
+          "type": "bytes4"
+        }
+      ],
+      "name": "supportsInterface",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/BytecodeStorageReaders/BytecodeStorageReaderContractV2.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+
+import {IBytecodeStorageReaderV2} from "../interfaces/v0.8.x/IBytecodeStorageReaderV2.sol";
+
+import {BytecodeStorageReader} from "../libs/v0.8.x/BytecodeStorageV2.sol";
+
+/**
+ * @title Art Blocks Bytecode Storage Reader Contract V2
+ * @author Art Blocks Inc.
+ * @notice This contract is used to read the bytecode of a contract deployed by Art Blocks' BytecodeStorage library,
+ * for versions 0, 1, and 2 of the Art Blocks BytecodeStorage library.
+ * It is permissionless and can be used by anyone to read the bytecode of any contract deployed by Art Blocks.
+ * Future versions of BytecodeStorage will not be compatible with this reader.
+ * For a single location to read current and future versions of the Art Blocks BytecodeStorage library, see
+ * the UniversalBytecodeStorageReader contract, maintained by the Art Blocks team.
+ * Additional functionality is provided to read bytes data stored using the SSTORE2 library.
+ * This contract also provides an interface to read additional metadata stored by the Art Blocks BytecodeStorage
+ * library, such as the contract's version, deployer, and other metadata.
+ * @dev For simplicity and reduce code changes, this contract uses the BytecodeStorageReader external library to
+ * perform many operations. Future reader contract versions may choose to make the library internal to this contract to
+ * improve read operation performance.
+ */
+contract BytecodeStorageReaderContractV2 is IBytecodeStorageReaderV2 {
+    using BytecodeStorageReader for address;
+
+    string public constant VERSION = "BytecodeStorageReaderContractV2";
+
+    /**
+     * @notice Read a string from a data contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of contract deployed via BytecodeStorage to be read
+     * @return The string data stored at the specific address.
+     */
+    function readFromBytecode(
+        address address_
+    ) external view returns (string memory) {
+        return address_.readFromBytecode();
+    }
+
+    /**
+     * @notice Read a bytes array from the SSTORE2-formatted bytecode of a contract.
+     * Note that this function is only compatible with contracts that have been deployed using the popular SSTORE2
+     * library.
+     * @param address_ address of contract with SSTORE2-formatted bytecode to be read
+     * @return data The bytes data stored at the specific address.
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address address_
+    ) external view returns (bytes memory) {
+        return address_.readBytesFromSSTORE2Bytecode();
+    }
+
+    /**
+     * @notice Read a bytes array from the a contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of contract with valid bytecode to be read
+     * @param offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return The bytes data stored at the specific address.
+     */
+    function readBytesFromBytecode(
+        address address_,
+        uint256 offset
+    ) external view returns (bytes memory) {
+        return address_.readBytesFromBytecode(offset);
+    }
+
+    //------ Metadata Functions ------//
+
+    /**
+     * @notice Get address of deployer for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return writerAddress address of deployer
+     */
+    function getWriterAddressForBytecode(
+        address address_
+    ) external view returns (address) {
+        return address_.getWriterAddressForBytecode();
+    }
+
+    /**
+     * @notice Get version for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return version version of the contract
+     */
+    function getLibraryVersionForBytecode(
+        address address_
+    ) external view returns (bytes32) {
+        return address_.getLibraryVersionForBytecode();
+    }
+
+    /**
+     * @notice Get if data are stored in compressed format for given contract deployed via BytecodeStorage V2 or
+     * earlier.
+     * @param _address address of deployed contract
+     * @return isCompressed boolean indicating if the stored data are compressed
+     */
+    function getIsCompressedForBytecode(
+        address _address
+    ) external view returns (bool) {
+        return _address.getIsCompressedForBytecode();
+    }
+}

package/contracts/BytecodeStorageReaders/BytecodeStorageReaderContractV2_Web3Call.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+
+import {IBytecodeStorageReaderV2} from "../interfaces/v0.8.x/IBytecodeStorageReaderV2.sol";
+import {IWeb3Call} from "../interfaces/v0.8.x/IWeb3Call.sol";
+
+import {BytecodeStorageReader} from "../libs/v0.8.x/BytecodeStorageV2.sol";
+
+import {ERC165Checker} from "@openzeppelin-5.0/contracts/utils/introspection/ERC165Checker.sol";
+
+/**
+ * @title Art Blocks Bytecode Storage Reader Contract V2 w/ Web3Call Support
+ * @author Art Blocks Inc.
+ * @notice This contract is used to read the bytecode of a contract deployed by Art Blocks' BytecodeStorage library,
+ * for versions 0, 1, and 2 of the Art Blocks BytecodeStorage library.
+ * It includes support for returning the special string "#web3call_contract#" when reading a non-bytecode storage
+ * contract that does indicate ERC165 support for the IWeb3Call interface, enabling backwards-compatibility with
+ * Web3Call-based projects on exiting Art Blocks contracts. This only affects the readFromBytecode function.
+ * It is permissionless and can be used by anyone to read the bytecode of any contract deployed by Art Blocks.
+ * Future versions of BytecodeStorage will not be compatible with this reader.
+ * For a single location to read current and future versions of the Art Blocks BytecodeStorage library, see
+ * the UniversalBytecodeStorageReader contract, maintained by the Art Blocks team.
+ * Additional functionality is provided to read bytes data stored using the SSTORE2 library.
+ * This contract also provides an interface to read additional metadata stored by the Art Blocks BytecodeStorage
+ * library, such as the contract's version, deployer, and other metadata.
+ * @dev For simplicity and reduce code changes, this contract uses the BytecodeStorageReader external library to
+ * perform many operations. Future reader contract versions may choose to make the library internal to this contract to
+ * improve read operation performance.
+ */
+contract BytecodeStorageReaderContractV2_Web3Call is IBytecodeStorageReaderV2 {
+    using BytecodeStorageReader for address;
+
+    string public constant VERSION = "BytecodeStorageReaderContractV2_Web3Call";
+
+    /**
+     * @notice Read a string from a data contract deployed via BytecodeStorage V2 or earlier.
+     * Also supports returning "#web3call_contract#" when the contract is not a
+     * BytecodeStorage contract, but does support the IWeb3Call interface.
+     * Reverts if the contract is not a BytecodeStorage contract and does not indicate
+     * ERC165 support for the IWeb3Call interface.
+     * @param address_ address of contract deployed via BytecodeStorage to be read
+     * @return The string data stored at the specific address.
+     */
+    function readFromBytecode(
+        address address_
+    ) external view returns (string memory) {
+        try address_.readFromBytecode() returns (string memory data) {
+            return data;
+        } catch {
+            if (
+                ERC165Checker.supportsInterface(
+                    address_,
+                    type(IWeb3Call).interfaceId
+                )
+            ) {
+                return "#web3call_contract#";
+            }
+        }
+        // reading from bytecode failed, and does not indicate Web3Call support, so revert
+        revert(
+            "BytecodeStorageReaderContractV2_Web3Call: Failed to read from bytecode"
+        );
+    }
+
+    /**
+     * @notice Read a bytes array from the SSTORE2-formatted bytecode of a contract.
+     * Note that this function is only compatible with contracts that have been deployed using the popular SSTORE2
+     * library.
+     * @param address_ address of contract with SSTORE2-formatted bytecode to be read
+     * @return data The bytes data stored at the specific address.
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address address_
+    ) external view returns (bytes memory) {
+        return address_.readBytesFromSSTORE2Bytecode();
+    }
+
+    /**
+     * @notice Read a bytes array from the a contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of contract with valid bytecode to be read
+     * @param offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return The bytes data stored at the specific address.
+     */
+    function readBytesFromBytecode(
+        address address_,
+        uint256 offset
+    ) external view returns (bytes memory) {
+        return address_.readBytesFromBytecode(offset);
+    }
+
+    //------ Metadata Functions ------//
+
+    /**
+     * @notice Get address of deployer for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return writerAddress address of deployer
+     */
+    function getWriterAddressForBytecode(
+        address address_
+    ) external view returns (address) {
+        return address_.getWriterAddressForBytecode();
+    }
+
+    /**
+     * @notice Get version for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return version version of the contract
+     */
+    function getLibraryVersionForBytecode(
+        address address_
+    ) external view returns (bytes32) {
+        return address_.getLibraryVersionForBytecode();
+    }
+
+    /**
+     * @notice Get if data are stored in compressed format for given contract deployed via BytecodeStorage V2 or
+     * earlier.
+     * @param _address address of deployed contract
+     * @return isCompressed boolean indicating if the stored data are compressed
+     */
+    function getIsCompressedForBytecode(
+        address _address
+    ) external view returns (bool) {
+        return _address.getIsCompressedForBytecode();
+    }
+}

package/contracts/BytecodeStorageReaders/UniversalBytecodeStorageReader.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+
+import {IUniversalBytecodeStorageReader} from "../interfaces/v0.8.x/IUniversalBytecodeStorageReader.sol";
+
+import {IBytecodeStorageReader_Base} from "../interfaces/v0.8.x/IBytecodeStorageReader_Base.sol";
+
+import "@openzeppelin-5.0/contracts/access/Ownable.sol";
+
+/**
+ * @title Art Blocks Universal Bytecode Storage Reader
+ * @author Art Blocks Inc.
+ * @notice This contract is used to read the bytecode of a contract deployed by Art Blocks' BytecodeStorage library.
+ * It is designed to be owned and configurable by a Art Blocks secure multisig wallet, providing a single location
+ * to read on-chain data stored by the Art Blocks BytecodeStorage libarary. This contract is intended to be updated
+ * as new versions of the Art Blocks BytecodeStorage library are released, such that the Art Blocks community can
+ * continue to read the bytecode of all existing and future Art Blocks contracts in a single location.
+ * The exposed interface is simplified to only include the read string function.
+ * Additional functionality, such as alternate read methods or determining a contract's version, deployer, and other
+ * metadata, may be available on the active BytecodeStorageReader contract.
+ */
+contract UniversalBytecodeStorageReader is
+    Ownable,
+    IUniversalBytecodeStorageReader
+{
+    /**
+     * @notice The active bytecode storage reader contract being used by this universal reader.
+     * Updateable by the owner of this contract.
+     * This contract is intended to be updated as new versions of the Art Blocks BytecodeStorage library are released.
+     * @dev To prevent a single point of failure, contracts may point directly to BytecodeStorageReader contracts
+     * instead of this universal reader.
+     */
+    IBytecodeStorageReader_Base public activeBytecodeStorageReaderContract;
+
+    /**
+     * @notice Construct a new UniversalBytecodeStorageReader contract, owned by input owner address.
+     * @param owner_ The address that will be set as the owner of this contract.
+     */
+    constructor(address owner_) Ownable(owner_) {}
+
+    /**
+     * @notice Update the active bytecode storage reader contract being used by this universal reader.
+     * @param newBytecodeStorageReaderContract The address of the new active bytecode storage reader contract.
+     */
+    function updateBytecodeStorageReaderContract(
+        IBytecodeStorageReader_Base newBytecodeStorageReaderContract
+    ) external onlyOwner {
+        activeBytecodeStorageReaderContract = newBytecodeStorageReaderContract;
+        emit ReaderUpdated({
+            activeReader: address(newBytecodeStorageReaderContract)
+        });
+    }
+
+    /**
+     * @notice Read a string from a data contract deployed via BytecodeStorage.
+     * @dev may also support reading additional stored data formats in the future.
+     * @param address_ address of contract deployed via BytecodeStorage to be read
+     * @return The string data stored at the specific address.
+     */
+    function readFromBytecode(
+        address address_
+    ) external view returns (string memory) {
+        return
+            activeBytecodeStorageReaderContract.readFromBytecode({
+                address_: address_
+            });
+    }
+}

package/contracts/BytecodeStorageV2Writer.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+import "./libs/v0.8.x/BytecodeStorageV2.sol";
+
+/**
+ * @title Art Blocks Storage Writer
+ * @author Art Blocks Inc.
+ * @notice A simple contract that with a single function that uses
+ * the BytecodeStorageV1 library to write a string to bytecode storage.
+ */
+contract BytecodeStorageV2Writer {
+    using BytecodeStorageWriter for bytes;
+    using BytecodeStorageReader for string;
+
+    event StorageContractCreated(address indexed storageContract);
+
+    function _onlyNonEmptyString(string memory _string) internal pure {
+        if (bytes(_string).length == 0) {
+            revert("String must be non-empty");
+        }
+    }
+
+    /**
+     * @notice Write a string to bytecode storage.
+     * @param _string The string to write to bytecode storage.
+     * @dev This function emits an event with the address of the newly created
+     * storage contract.
+     */
+    function writeStringToBytecodeStorage(string memory _string) public {
+        address storageContract = BytecodeStorageWriter.writeToBytecode(
+            _string
+        );
+        emit StorageContractCreated(storageContract);
+    }
+
+    /**
+     * @notice Write a pre-compressed string to bytecode storage. The string
+     * should be compressed using `getCompressed`. This function stores the string
+     * in a compressed format on-chain. For reads, the compressed string is
+     * decompressed on-chain, ensuring the original text is reconstructed without
+     * external dependencies.
+     * @param _compressedString Pre-compressed string to be stored.
+     * Required to be non-empty, but no further validation is performed.
+     * @dev This function emits an event with the address of the newly created
+     * storage contract.
+     */
+    function writeCompressedStringToBytecodeStorage(
+        bytes memory _compressedString
+    ) public {
+        address storageContract = BytecodeStorageWriter
+            .writeToBytecodeCompressed(_compressedString);
+        emit StorageContractCreated(storageContract);
+    }
+
+    /**
+     * @notice Returns the compressed form of a string in bytes using solady LibZip's flz compress algorithm.
+     * The bytes output from this function are intended to be used as input to `writeCompressedStringToBytecodeStorage`.
+     * @param _string String to be compressed. Required to be a non-empty string, but no further validaton is performed.
+     * @return bytes compressed bytes
+     */
+    function getCompressed(
+        string memory _string
+    ) external pure returns (bytes memory) {
+        _onlyNonEmptyString(_string);
+        return BytecodeStorageReader.getCompressed(_string);
+    }
+}