// SPDX-License-Identifier: MIT import {Ownable} from "solady/src/auth/Ownable.sol"; import {Base64} from "solady/src/utils/Base64.sol"; import {IColorgasmArtworkSource, IColorgasmBlobStorage, IColorgasmRenderer} from "./interfaces/IColorgasm.sol"; /// @title COLORGASM onchain renderer, v3 — single-pass assembly /// @notice Builds the whole token document in ONE buffer: the output is sized /// exactly, allocated once, and every byte is written into its final /// place and never moved again. v1 and v2 both built the image, then a /// base64 of it, then the JSON, then sometimes a base64 of that — four /// full-size buffers, and EVM memory is billed with the square of how /// Two storage shapes, chosen per deployment: /// PRE-ENCODED (`preEncoded = true`, the cheapest to render) — the /// bytes in storage are already the base64 of the image, so rendering /// is a straight `extcodecopy` of each chunk into the output. No /// encoding onchain at all. Costs 33% more to store, since base64 is /// RAW (`preEncoded = false`) — the bytes in storage are the image /// itself and the renderer base64s them. Because ColorgasmStorage caps /// chunks at a multiple of 3, each chunk encodes independently and the /// results concatenate exactly, so this still needs only one scratch /// chunk of working memory rather than a copy of the whole image. /// Cheapest to store; slightly more expensive to render. /// Both produce byte-identical documents. Measure both for your own /// sizes with `npm run ceiling` before committing to either. /// @dev Reads the artwork pointer (a storage key) and the metadata fragment /// from the extension, then the chunk pointers from the blob storage. /// Nothing here is token-aware beyond that, so it is a plain /// `setRenderer()` swap. contract ColorgasmRendererV3 is Ownable, IColorgasmRenderer { error ChunkNotAligned(uint256 index); /// @notice The redeem extension: artwork pointers and metadata fragments. IColorgasmArtworkSource public immutable source; /// @notice Where the artwork bytes live. IColorgasmBlobStorage public immutable blobs; /// @notice MIME type used for the image data URI. /// @notice True when stored bytes are already base64 of the image. bool public immutable preEncoded; /// @notice When true the JSON document is base64-encoded (maximum /// compatibility); when false it is served as UTF-8, which is /// roughly half the gas and what makes large tokens renderable. constructor(address source_, address blobs_, bool preEncoded_) { _initializeOwner(msg.sender); source = IColorgasmArtworkSource(source_); blobs = IColorgasmBlobStorage(blobs_); preEncoded = preEncoded_; imageMime = "image/avif"; function setImageMime(string calldata imageMime_) external onlyOwner { /// @notice Switch the JSON document between base64 and plain UTF-8. function setBase64Json(bool base64Json_) external onlyOwner { base64Json = base64Json_; /// @inheritdoc IColorgasmRenderer function tokenURI(address, uint256, uint256 originalTokenId) bytes memory json = _assemble(originalTokenId, ""); return string(abi.encodePacked("data:application/json;base64,", Base64.encode(json))); // The cheap path: the prefix is reserved at the front of the same // buffer, so the finished document is never copied again. return string(_assemble(originalTokenId, "data:application/json;utf8,")); /// @notice Size in bytes of the document `tokenURI` will return, without /// building it. Useful to check a token against an RPC's response /// limits before anyone tries to load it. function renderedSize(uint256 originalTokenId) external view returns (uint256) { (, uint256 imageChars) = _imageLayout(originalTokenId); bytes memory meta = source.metadataOf(originalTokenId); uint256 metaLen = base64Json ? meta.length : _escapeForUri(meta).length; uint256 json = _headLength(metaLen) + imageChars + 2; return base64Json ? 28 + 4 * ((json + 2) / 3) : 26 + json; // -------------------------------------------------------------- internal -- /// @dev `{` + fragment + `,` + `"image":"data:<mime>;base64,` function _headLength(uint256 metaLen) internal view returns (uint256) { // "{" + meta + ","(only when meta is present) // + '"image":"data:' (14) + mime + ';base64,' (8) return 1 + metaLen + (metaLen == 0 ? 0 : 1) + 14 + bytes(imageMime).length + 8; /// @dev Chunk pointers plus how many base64 characters they will produce. function _imageLayout(uint256 originalTokenId) returns (address[] memory pointers, uint256 imageChars) pointers = blobs.chunksOf(source.artworkKeyOf(originalTokenId)); uint256 n = pointers.length; if (n == 0) revert NothingStored(); for (uint256 i; i < n; ++i) { uint256 size = pointers[i].code.length - 1; // Every chunk but the last must be a multiple of 3, otherwise // encoding chunk by chunk would insert padding mid-image. if (!preEncoded && i + 1 < n && size % 3 != 0) revert ChunkNotAligned(i); imageChars = preEncoded ? dataLen : 4 * ((dataLen + 2) / 3); /// @dev Build `<prefix>{<meta>,"image":"data:<mime>;base64,<image>"}` into a /// single exactly-sized buffer. function _assemble(uint256 originalTokenId, bytes memory prefix) returns (bytes memory out) (address[] memory pointers, uint256 imageChars) = _imageLayout(originalTokenId); bytes memory meta = source.metadataOf(originalTokenId); if (!base64Json) meta = _escapeForUri(meta); bytes memory head = meta.length == 0 ? abi.encodePacked("{", '"image":"data:', imageMime, ";base64,") : abi.encodePacked("{", meta, ",", '"image":"data:', imageMime, ";base64,"); uint256 total = prefix.length + head.length + imageChars + 2; // Zero the final partial word so no stale memory can leak into the // string, then reserve the whole thing. let end := add(add(out, 0x20), total) mstore(0x40, add(out, and(add(add(total, 0x20), 0x3f), not(0x1f)))) dst = _copy(dst, prefix); uint256 n = pointers.length; for (uint256 i; i < n; ++i) { address pointer = pointers[i]; // Straight copy: the stored bytes are already base64. let size := sub(extcodesize(pointer), 1) extcodecopy(pointer, dst, 1, size) // Encode this chunk on its own and copy the result in. The // scratch and the encoder's output are both released again by // restoring the free-memory pointer, so working memory stays at // one chunk however many there are. let size := sub(extcodesize(pointer), 1) extcodecopy(pointer, add(raw, 0x20), 1, size) mstore(0x40, add(raw, and(add(add(size, 0x20), 0x3f), not(0x1f)))) dst = _copy(dst, bytes(Base64.encode(raw))); /// @dev Copy `data` to `dst`, returning the position just past it. function _copy(uint256 dst, bytes memory data) internal pure returns (uint256) { let src := add(data, 0x20) for { let o := 0 } lt(o, len) { o := add(o, 0x20) } { mstore(add(dst, o), mload(add(src, o))) /// @dev Percent-encode what would break a raw data URI. Every COLORGASM /// name contains a `#`, which starts the fragment and would truncate /// the document at the name; `%` starts an escape. Applied only to the /// metadata fragment — base64 output is URI-safe throughout. function _escapeForUri(bytes memory input) internal pure returns (bytes memory) { for (uint256 i; i < input.length; ++i) { uint8 c = uint8(input[i]); if (c == 0x25 || c == 0x23 || c < 0x21 || c > 0x7e) extra += 2; if (extra == 0) return input; bytes memory out = new bytes(input.length + extra); bytes16 hexDigits = "0123456789ABCDEF"; for (uint256 i; i < input.length; ++i) { uint8 c = uint8(input[i]); if (c == 0x25 || c == 0x23 || c < 0x21 || c > 0x7e) { out[j++] = hexDigits[c >> 4]; out[j++] = hexDigits[c & 0x0f];