@artblocks/contracts 1.1.0 → 1.2.1

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/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);
+    }
+}