@artblocks/contracts 1.3.2 → 1.4.0

package/contracts/web3call/augment-hooks/InjectBlockHeightProjectInvocationsAndArtistProjectOverrides.sol

@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";
+import {ABHelpers} from "../../libs/v0.8.x/ABHelpers.sol";
+
+import {IWeb3Call} from "../../interfaces/v0.8.x/IWeb3Call.sol";
+import {IGenArt721CoreContractV3_Base} from "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
+
+import {Strings} from "@openzeppelin-5.0/contracts/utils/Strings.sol";
+import {EnumerableMap} from "@openzeppelin-5.0/contracts/utils/structs/EnumerableMap.sol";
+
+/**
+ * @title InjectBlockHeightAndArtistProjectOverrides
+ * @author Art Blocks Inc.
+ * @notice This hook appends the current block height, current project invocations, and artist project overrides into a token's PMPs.
+ * If an input PMP has a key that matches an artist project override, the artist project override value will be used.
+ * If an override value is not in the input PMPs, it will be appended to the output, ensuring that the output always contains all override values.
+ * @dev This contract is developed open-source, is lightly tested, and should be used at your own risk.
+ * The artist can set and clear overrides for a project via the `artistSetProjectOverride` and `artistClearProjectOverride` functions.
+ * The artist can only set and clear overrides for their own projects.
+ * This contract is not owned, and intended to integrate with Art Blocks core contracts that conform to IGenArt721CoreContractV3_Base.
+ */
+contract InjectBlockHeightProjectInvocationsAndArtistProjectOverrides is
+    AbstractPMPAugmentHook
+{
+    using Strings for uint256;
+    using EnumerableMap for EnumerableMap.Bytes32ToBytes32Map;
+
+    event ArtistProjectOverrideSet(
+        address indexed coreContract,
+        uint256 indexed projectId,
+        string key,
+        string value
+    );
+
+    event ArtistProjectOverrideCleared(
+        address indexed coreContract,
+        uint256 indexed projectId,
+        string key
+    );
+
+    // enumerable mapping of project to artist pmp overrides
+    // @dev key/value pairs are stored as bytes32 values for gas efficiency and standard library compatibility
+    mapping(address coreContract => mapping(uint256 projectId => EnumerableMap.Bytes32ToBytes32Map enumerableOverrides))
+        private artistProjectOverrides;
+
+    /**
+     * @notice Set a project override for a given key.
+     * Only the artist of the project can set the project override.
+     * @dev intentionally does not emit events - artist overrides are intended to be not indexed.
+     * @param coreContract The address of the core contract.
+     * @param projectId The ID of the project.
+     * @param key The key to set.
+     * @param value The value to set.
+     */
+    function artistSetProjectOverride(
+        address coreContract,
+        uint256 projectId,
+        string memory key,
+        string memory value
+    ) external {
+        // CHECKS
+        _onlyArtist({
+            caller: msg.sender,
+            coreContract: coreContract,
+            projectId: projectId
+        });
+
+        // EFFECTS
+        EnumerableMap.Bytes32ToBytes32Map
+            storage overrides = artistProjectOverrides[coreContract][projectId];
+        overrides.set(_toBytes32(key), _toBytes32(value));
+
+        emit ArtistProjectOverrideSet({
+            coreContract: coreContract,
+            projectId: projectId,
+            key: key,
+            value: value
+        });
+    }
+
+    /**
+     * @notice Clear a project override for a given key.
+     * Only the artist of the project can clear the project override.
+     * @dev intentionally does not emit events - artist overrides are intended to be not indexed.
+     * @param coreContract The address of the core contract.
+     * @param projectId The ID of the project.
+     * @param key The key to clear.
+     */
+    function artistClearProjectOverride(
+        address coreContract,
+        uint256 projectId,
+        string memory key
+    ) external {
+        // CHECKS
+        _onlyArtist({
+            caller: msg.sender,
+            coreContract: coreContract,
+            projectId: projectId
+        });
+
+        // EFFECTS
+        EnumerableMap.Bytes32ToBytes32Map
+            storage overrides = artistProjectOverrides[coreContract][projectId];
+        require(overrides.remove(_toBytes32(key)), "Key not found");
+
+        emit ArtistProjectOverrideCleared({
+            coreContract: coreContract,
+            projectId: projectId,
+            key: key
+        });
+    }
+
+    /**
+     * @notice Get the artist project overrides for a given project.
+     * @dev This function is used to get the artist project overrides for a given project.
+     * @param coreContract The address of the core contract.
+     * @param projectId The ID of the project.
+     * @return projectOverrides The artist project overrides for the given project.
+     */
+    function getArtistProjectOverrides(
+        address coreContract,
+        uint256 projectId
+    ) external view returns (IWeb3Call.TokenParam[] memory projectOverrides) {
+        EnumerableMap.Bytes32ToBytes32Map
+            storage overrides = artistProjectOverrides[coreContract][projectId];
+        uint256 overrideCount = overrides.length();
+        // translate enumerable map to expected output format
+        projectOverrides = new IWeb3Call.TokenParam[](overrideCount);
+        for (uint256 i = 0; i < overrideCount; i++) {
+            (bytes32 key, bytes32 value) = overrides.at(i);
+            projectOverrides[i] = IWeb3Call.TokenParam({
+                key: _fromBytes32(key),
+                value: _fromBytes32(value)
+            });
+        }
+        // @dev implicitly return the projectOverrides array
+    }
+
+    /**
+     * @notice Augment the token parameters for a given token.
+     * Appends the block height and project invocations into a tokens PMPs, and injects artist project overrides.
+     * If an input PMP has a key that matches an artist project override, the artist project override value will be used.
+     * If an input PMP has a key that does not match an artist project override, the input PMP will be unaffected in the output.
+     * All overrides are appended to the output, ensuring that the output always contains all override values.
+     * @dev This hook is called when a token's PostParams are read.
+     * @dev This must return all desired tokenParams, not just additional data.
+     * @param tokenParams The token parameters for the queried token.
+     * @return augmentedTokenParams The augmented token parameters.
+     */
+    function onTokenPMPReadAugmentation(
+        address coreContract,
+        uint256 tokenId,
+        IWeb3Call.TokenParam[] calldata tokenParams
+    )
+        external
+        view
+        override
+        returns (IWeb3Call.TokenParam[] memory augmentedTokenParams)
+    {
+        // get artist project overrides
+        EnumerableMap.Bytes32ToBytes32Map
+            storage overrides = artistProjectOverrides[coreContract][
+                ABHelpers.tokenIdToProjectId({tokenId: tokenId}) // project id
+            ];
+        uint256 overrideCount = overrides.length();
+
+        // create a new augmentedTokenParams array with maximum length of
+        // input tokenParams + overrideCount + 2 extra elements for BlockHeight and project invocations
+        uint256 originalLength = tokenParams.length;
+        uint256 augmentedMaxLength = originalLength + overrideCount + 2; // +2 for block height and project invocations
+        augmentedTokenParams = new IWeb3Call.TokenParam[](augmentedMaxLength);
+
+        // copy the original tokenParams into the new array
+        for (uint256 i = 0; i < originalLength; i++) {
+            augmentedTokenParams[i] = tokenParams[i];
+        }
+
+        // get + inject the block height into the new array
+        // @dev block scope to avoid stack too deep error
+        {
+            uint256 currentBlock = block.number;
+            augmentedTokenParams[originalLength] = IWeb3Call.TokenParam({
+                key: "blockHeight",
+                value: currentBlock.toString()
+            });
+        }
+
+        // get + inject the project invocations into the new array
+        {
+            uint256 projectId = ABHelpers.tokenIdToProjectId({
+                tokenId: tokenId
+            });
+            (uint256 invocations, , , , , ) = IGenArt721CoreContractV3_Base(
+                coreContract
+            ).projectStateData(projectId);
+            augmentedTokenParams[originalLength + 1] = IWeb3Call.TokenParam({
+                key: "projectInvocations",
+                value: invocations.toString()
+            });
+        }
+
+        // get + inject the artist project overrides into the new array, overriding any existing param values
+        uint256 nextIndex = originalLength + 2;
+        // @dev O(i*n) where i is the number of overrides and n is the number of original tokenParams, okay on read function
+        for (uint256 i = 0; i < overrideCount; i++) {
+            (bytes32 key, bytes32 value) = overrides.at(i);
+            // check if the key exists in the original tokenParams, and if so, override the value with artist override
+            bool found = false;
+            for (uint256 j = 0; j < originalLength; j++) {
+                if (_equalsStringAndBytes32({s: tokenParams[j].key, b: key})) {
+                    augmentedTokenParams[j] = IWeb3Call.TokenParam({
+                        key: tokenParams[j].key, // @dev key is not changed
+                        value: _fromBytes32(value) // @dev value is overridden
+                    });
+                    found = true;
+                    break;
+                }
+            }
+            // if the key did not exist in the original tokenParams, append it to the augmentedTokenParams array
+            if (!found) {
+                augmentedTokenParams[nextIndex++] = IWeb3Call.TokenParam({
+                    key: _fromBytes32(key),
+                    value: _fromBytes32(value)
+                });
+            }
+        }
+
+        // shorten the augmentedTokenParams array to the new length (which is nextIndex)
+        // @dev use assembly to efficiently modify in place
+        if (nextIndex < augmentedMaxLength) {
+            assembly {
+                mstore(augmentedTokenParams, nextIndex)
+            }
+        }
+
+        // return the augmented tokenParams
+        return augmentedTokenParams;
+    }
+
+    /**
+     * @notice Only the artist of the project can call the function.
+     * @dev reverts if the caller is not the artist of the project.
+     * @param caller The address of the caller.
+     * @param coreContract The address of the core contract.
+     * @param projectId The ID of the project.
+     */
+    function _onlyArtist(
+        address caller,
+        address coreContract,
+        uint256 projectId
+    ) internal view {
+        if (
+            caller !=
+            IGenArt721CoreContractV3_Base(coreContract)
+                .projectIdToArtistAddress(projectId)
+        ) {
+            revert("Only artist of project");
+        }
+    }
+
+    /**
+     * @notice Convert a string to a bytes32 value.
+     * Reverts if the string is longer than 32 bytes.
+     * @dev This is a helper function to convert a string to a bytes32 value.
+     * @param str The string to convert.
+     * @return result The bytes32 value of the string.
+     */
+    function _toBytes32(
+        string memory str
+    ) internal pure returns (bytes32 result) {
+        bytes memory temp = bytes(str);
+        if (temp.length > 32) {
+            revert("String too long");
+        }
+        // copy the string directly to the bytes32 result, skipping the first 32 bytes (string length)
+        assembly {
+            result := mload(add(str, 32))
+        }
+    }
+
+    /**
+     * @notice Convert a bytes32-encoded string value to a string.
+     * @dev This is a helper function to convert a bytes32-encoded string value to a string.
+     * @param b The bytes32 value to convert.
+     * @return The string value of the bytes32 value.
+     */
+    function _fromBytes32(bytes32 b) internal pure returns (string memory) {
+        // determine the length of the string
+        uint256 len = 0;
+        for (; len < 32; ++len) {
+            if (b[len] == 0) break;
+        }
+        // create a new string with the length of the string
+        // @dev solidity reserves 32 bytes for length, rounds up to full word for data portion
+        string memory result = new string(len);
+        assembly {
+            let resultData := add(result, 0x20) // skip length prefix (already populated)
+            mstore(resultData, b) // store full 32 bytes (write-ahead optimization, okay due to solidity reserving 32 bytes for data)
+        }
+        return result;
+    }
+
+    /**
+     * @notice Compare a string and a bytes32 value, assuming the bytes32 is an encoded string.
+     * @dev This is a helper function to compare a string and a bytes32 value.
+     * @param s The string to compare.
+     * @param b The bytes32 value to compare.
+     * @return true if the string and bytes32 value are equal, false otherwise.
+     */
+    function _equalsStringAndBytes32(
+        string memory s,
+        bytes32 b
+    ) internal pure returns (bool) {
+        bytes memory strBytes = bytes(s);
+        if (strBytes.length > 32) return false;
+        bytes32 strBytes32;
+        assembly {
+            strBytes32 := mload(add(s, 32))
+        }
+        return strBytes32 == b;
+    }
+}

package/contracts/web3call/augment-hooks/InjectBlockTimestamp.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";
+
+import {IWeb3Call} from "../../interfaces/v0.8.x/IWeb3Call.sol";
+import {Strings} from "@openzeppelin-5.0/contracts/utils/Strings.sol";
+
+/**
+ * @title InjectBlockTimestamp
+ * @author Art Blocks Inc.
+ * @notice This hook injects the current block timestamp into a token's PMPs.
+ */
+contract InjectBlockTimestamp is AbstractPMPAugmentHook {
+    using Strings for uint256;
+
+    /**
+     * @notice Augment the token parameters for a given token.
+     * Appends the block timestamp into a tokens PMPs.
+     * @dev This hook is called when a token's PMPs are read.
+     * @dev This must return all desired tokenParams, not just additional data.
+     * @param tokenParams The token parameters for the queried token.
+     * @return augmentedTokenParams The augmented token parameters.
+     */
+    function onTokenPMPReadAugmentation(
+        address /* coreContract */,
+        uint256 /* tokenId */,
+        IWeb3Call.TokenParam[] calldata tokenParams
+    )
+        external
+        view
+        override
+        returns (IWeb3Call.TokenParam[] memory augmentedTokenParams)
+    {
+        // create a new tokenParam array with one extra element
+        uint256 originalLength = tokenParams.length;
+        uint256 newLength = originalLength + 1;
+        augmentedTokenParams = new IWeb3Call.TokenParam[](newLength);
+
+        // copy the original tokenParams into the new array
+        for (uint256 i = 0; i < originalLength; i++) {
+            augmentedTokenParams[i] = tokenParams[i];
+        }
+
+        // get + inject the block timestamp into the new array
+        uint256 currentTimestamp = block.timestamp;
+        augmentedTokenParams[originalLength] = IWeb3Call.TokenParam({
+            key: "blockTimestamp",
+            value: currentTimestamp.toString()
+        });
+
+        // return the augmented tokenParams
+        return augmentedTokenParams;
+    }
+}

package/contracts/web3call/augment-hooks/InjectBytesPerToken.sol

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";
+
+import {IWeb3Call} from "../../interfaces/v0.8.x/IWeb3Call.sol";
+import {SSTORE2} from "../../libs/v0.8.x/SSTORE2.sol";
+import {ABHelpers} from "../../libs/v0.8.x/ABHelpers.sol";
+
+import {Strings} from "@openzeppelin-5.0/contracts/utils/Strings.sol";
+import {Ownable} from "@openzeppelin-5.0/contracts/access/Ownable.sol";
+
+/**
+ * @title InjectBytesPerToken
+ * @author Art Blocks Inc.
+ * @notice This hook injects uploaded bytes per token, into a token's PMPs.
+ */
+contract InjectBytesPerToken is AbstractPMPAugmentHook, Ownable {
+    using Strings for uint256;
+
+    event TokenDataUploadedAtIndex(
+        uint256 indexed tokenNumber,
+        uint256 indexed chunkIndex,
+        address dataPointer
+    );
+    event TokenDataClearedAtIndex(
+        uint256 indexed tokenNumber,
+        uint256 indexed chunkIndex
+    );
+
+    // mapping of token number to chunk index to data pointer (SSTORE2 pointer)
+    mapping(uint256 tokenNumber => mapping(uint256 chunkIndex => address dataPointer))
+        public tokenDataPointers;
+
+    // mapping of token number to highest chunk index
+    mapping(uint256 tokenNumber => uint256 numChunks) public numChunksOfToken;
+
+    /**
+     * @notice Constructor
+     * @param owner_ The owner of the contract.
+     */
+    constructor(address owner_) Ownable(owner_) {}
+
+    /**
+     * @notice Augment the token parameters for a given token.
+     * Appends uploaded bytes per token into a tokens PMPs.
+     * @dev This hook is called when a token's PMPs are read.
+     * @dev This must return all desired tokenParams, not just additional data.
+     * @param tokenParams The token parameters for the queried token.
+     * @return augmentedTokenParams The augmented token parameters.
+     */
+    function onTokenPMPReadAugmentation(
+        address /* coreContract */,
+        uint256 tokenId,
+        IWeb3Call.TokenParam[] calldata tokenParams
+    )
+        external
+        view
+        override
+        returns (IWeb3Call.TokenParam[] memory augmentedTokenParams)
+    {
+        // create a new tokenParam array with one extra element
+        uint256 originalLength = tokenParams.length;
+        uint256 newLength = originalLength + 1;
+        augmentedTokenParams = new IWeb3Call.TokenParam[](newLength);
+
+        // copy the original tokenParams into the new array
+        for (uint256 i = 0; i < originalLength; i++) {
+            augmentedTokenParams[i] = tokenParams[i];
+        }
+
+        // get + inject the uploaded bytes per token into the new array
+        uint256 tokenNumber = ABHelpers.tokenIdToTokenNumber(tokenId);
+        augmentedTokenParams[originalLength] = IWeb3Call.TokenParam({
+            key: "tokenData",
+            value: getAllTokenDataAsHexString(tokenNumber)
+        });
+
+        // return the augmented tokenParams
+        return augmentedTokenParams;
+    }
+
+    /**
+     * @notice Upload token data at a specific chunk index
+     * @param tokenNumber The token number (not token ID) - derived from tokenId % 1,000,000
+     * @param chunkIndex The chunk index (must be sequential - either append to end or overwrite existing)
+     * @param data The bytes to store (deployed as SSTORE2 contract)
+     * @dev Can overwrite existing chunks. Old SSTORE2 contract remains deployed but orphaned.
+     * @dev Only owner can call this function.
+     * @dev Emits TokenDataUploadedAtIndex event.
+     */
+    function uploadTokenDataAtIndex(
+        uint256 tokenNumber,
+        uint256 chunkIndex,
+        bytes memory data
+    ) external onlyOwner {
+        // CHECKS
+        // only allow appending to the end of the data
+        uint256 numChunksBefore = numChunksOfToken[tokenNumber];
+        require(
+            chunkIndex <= numChunksBefore,
+            "Must append to end of current array of chunks"
+        );
+
+        // EFFECTS
+        // update the number of chunks for the token
+        if (chunkIndex == numChunksBefore) {
+            numChunksOfToken[tokenNumber] = chunkIndex + 1;
+        }
+
+        // upload the data to SSTORE2
+        address dataPointer = SSTORE2.write(data);
+        tokenDataPointers[tokenNumber][chunkIndex] = dataPointer;
+
+        // emit an event
+        emit TokenDataUploadedAtIndex({
+            tokenNumber: tokenNumber,
+            chunkIndex: chunkIndex,
+            dataPointer: dataPointer
+        });
+    }
+
+    /**
+     * @notice Clear token data at a specific chunk index
+     * @param tokenNumber The token number (not token ID)
+     * @param chunkIndex The chunk index to clear (must be an existing chunk)
+     * @dev Sets the chunk pointer to address(0). Does not delete the SSTORE2 contract.
+     * @dev If clearing the last chunk, numChunksOfToken is updated by searching backwards for the last non-zero chunk.
+     * @dev If clearing a middle chunk, numChunksOfToken remains unchanged (gaps are allowed).
+     * @dev Only owner can call this function.
+     * @dev Emits TokenDataClearedAtIndex event.
+     */
+    function clearTokenDataAtIndex(
+        uint256 tokenNumber,
+        uint256 chunkIndex
+    ) external onlyOwner {
+        // CHECKS
+        // only allow clearing existing chunks
+        uint256 numChunksBefore = numChunksOfToken[tokenNumber];
+        require(chunkIndex < numChunksBefore, "Must clear an existing chunk");
+
+        // EFFECTS
+        // clear the data from SSTORE2
+        tokenDataPointers[tokenNumber][chunkIndex] = address(0);
+
+        // update the number of chunks for the token if this was the last chunk
+        if (chunkIndex == numChunksBefore - 1) {
+            // Search backwards from the cleared chunk to find the new last non-zero chunk
+            uint256 newNumChunks = 0;
+            for (uint256 i = chunkIndex; i > 0; ) {
+                unchecked {
+                    i--;
+                }
+                if (tokenDataPointers[tokenNumber][i] != address(0)) {
+                    newNumChunks = i + 1;
+                    break;
+                }
+            }
+            numChunksOfToken[tokenNumber] = newNumChunks;
+        }
+
+        // emit an event
+        emit TokenDataClearedAtIndex({
+            tokenNumber: tokenNumber,
+            chunkIndex: chunkIndex
+        });
+    }
+
+    /**
+     * @notice Get token data at a specific chunk index
+     * @param tokenNumber The token number (not token ID)
+     * @param chunkIndex The chunk index to retrieve (must be less than numChunksOfToken)
+     * @return The bytes stored at the given chunk index (empty bytes if chunk was cleared)
+     * @dev Returns empty bytes (0x) if the chunk pointer is address(0) (cleared chunk).
+     */
+    function getTokenDataAtIndex(
+        uint256 tokenNumber,
+        uint256 chunkIndex
+    ) public view returns (bytes memory) {
+        // CHECKS
+        // only allow getting existing chunks
+        uint256 numChunks = numChunksOfToken[tokenNumber];
+        require(chunkIndex < numChunks, "Must get an existing chunk");
+
+        // get the data from SSTORE2
+        address dataPointer = tokenDataPointers[tokenNumber][chunkIndex];
+        // if a cleared chunk, return an empty bytes array
+        if (dataPointer == address(0)) {
+            return bytes("");
+        }
+        // return the data from SSTORE2
+        return SSTORE2.read(dataPointer);
+    }
+
+    /**
+     * @notice Get all token data concatenated from all chunks
+     * @param tokenNumber The token number (not token ID)
+     * @return All bytes concatenated from all chunks (skips cleared chunks with empty data)
+     * @dev Iterates through all chunks up to numChunksOfToken and concatenates non-empty chunks.
+     * @dev Gas consumption scales with number of chunks and total data size.
+     */
+    function getAllTokenData(
+        uint256 tokenNumber
+    ) public view returns (bytes memory) {
+        // get the number of chunks for the token
+        uint256 numChunks = numChunksOfToken[tokenNumber];
+        // iterate over all chunks and get the data from SSTORE2
+        bytes memory allData;
+        for (uint256 i = 0; i < numChunks; i++) {
+            bytes memory chunkData = getTokenDataAtIndex(tokenNumber, i);
+            if (chunkData.length > 0) {
+                allData = bytes.concat(allData, chunkData);
+            }
+        }
+        return allData;
+    }
+
+    /**
+     * @notice Get all token data as a hex-encoded string with "0x" prefix
+     * @param tokenNumber The token number (not token ID)
+     * @return Hex string representation of all concatenated token data (e.g., "0x414243" for "ABC")
+     * @dev Returns "0x" if token has no data.
+     * @dev Uses Solady's efficient hex encoding implementation.
+     */
+    function getAllTokenDataAsHexString(
+        uint256 tokenNumber
+    ) public view returns (string memory) {
+        bytes memory data = getAllTokenData(tokenNumber);
+        return toHexString(data);
+    }
+
+    // --- HELPER FUNCTIONS FROM SOLADY https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol ---
+
+    /// @dev Returns the hex encoded string from the raw bytes.
+    /// The output is encoded using 2 hexadecimal digits per byte.
+    function toHexString(
+        bytes memory raw
+    ) internal pure returns (string memory result) {
+        result = toHexStringNoPrefix(raw);
+        /// @solidity memory-safe-assembly
+        assembly {
+            let n := add(mload(result), 2) // Compute the length.
+            mstore(result, 0x3078) // Store the "0x" prefix.
+            result := sub(result, 2) // Move the pointer.
+            mstore(result, n) // Store the length.
+        }
+    }
+
+    /// @dev Returns the hex encoded string from the raw bytes.
+    /// The output is encoded using 2 hexadecimal digits per byte.
+    function toHexStringNoPrefix(
+        bytes memory raw
+    ) internal pure returns (string memory result) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            let n := mload(raw)
+            result := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
+            mstore(result, add(n, n)) // Store the length of the output.
+
+            mstore(0x0f, 0x30313233343536373839616263646566) // Store the "0123456789abcdef" lookup.
+            let o := add(result, 0x20)
+            let end := add(raw, n)
+            for {
+
+            } iszero(eq(raw, end)) {
+
+            } {
+                raw := add(raw, 1)
+                mstore8(add(o, 1), mload(and(mload(raw), 15)))
+                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
+                o := add(o, 2)
+            }
+            mstore(o, 0) // Zeroize the slot after the string.
+            mstore(0x40, add(o, 0x20)) // Allocate memory.
+        }
+    }
+}

package/contracts/web3call/augment-hooks/InjectIsProjectFullyMinted.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-pragma solidity ^0.8.0;
+pragma solidity 0.8.22;
 
 import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";
 

package/contracts/web3call/augment-hooks/InjectTokenHashSeed.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-pragma solidity ^0.8.0;
+pragma solidity 0.8.22;
 
 import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";
 

package/contracts/web3call/augment-hooks/InjectTokenOwner.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-pragma solidity ^0.8.0;
+pragma solidity 0.8.22;
 
 import {AbstractPMPAugmentHook} from "./AbstractPMPAugmentHook.sol";