DotGrid rendererLink to this section

OverviewLink to this section

The renderer reads a DotGrid page, a 44-byte header and ten ordered sections stored as contract code in a page root and its chunks, and derives each token's traits and image from the collection seed and token ID. The page validator checks a page's full structure. Neither holds state or emits events.

FunctionsLink to this section

ViewsLink to this section

tokenURILink to this section

function tokenURI(address page, bytes32 seed, uint256 tokenId) external view returns (string);

Strictly reads and fully validates page, then returns base64 JSON metadata with an embedded SVG for tokenId.

Reverts with DotGridInvalid(code) for any page or input failure.

tokenURIForPinnedPageLink to this section

function tokenURIForPinnedPage(address page, bytes32 codehash, bytes32 seed, uint256 tokenId) external view returns (string);

Like tokenURI, but skips full validation when the page root's runtime hash equals codehash. SqueekNFT uses it after validating the page at construction. Supplying a codehash does not establish trust: validate that exact root first. Reverts with DotGridInvalid(132) on a mismatch.

renderSVGLink to this section

function renderSVG(address page, bytes32 seed, uint256 tokenId) external view returns (string);
function renderSVGForPinnedPage(address page, bytes32 codehash, bytes32 seed, uint256 tokenId) external view returns (string);

The SVG alone, strict or pinned.

traitWordLink to this section

function traitWord(address page, bytes32 seed, uint256 tokenId) external view returns (uint256);
function resolvedFieldHash(address page, bytes32 seed, uint256 tokenId) external view returns (bytes32);

The packed deterministic trait choices, and a commitment to the resolved emitter field. Both also appear in the metadata.

validatePageLink to this section

function validatePage(address page) external view returns (bytes32 pageHash, bytes32 assetSetHash);

Strict read plus full validation. Returns the logical page hash and the asset-set hash, which SqueekNFT stores as sceneHash() and assetSetHash().

IdentityLink to this section

function rendererId() external pure returns (bytes32);
function rendererVersion() external pure returns (string);
function pageValidator() external view returns (address);

rendererId() is keccak256("sqk.dotgrid-renderer.v1") and rendererVersion() is sqk.dotgrid-renderer.v1. pageValidator() is the validator the renderer created; its code is not covered by the renderer's runtime hash, so pin it separately.

validateLink to this section

function validate(bytes page) external pure returns (Layout layout);

On the page validator. Validates raw logical page bytes and returns the section directory. Most integrators call validatePage on the renderer instead.

Metadata fieldsLink to this section

The asset-set hash binds page and renderer: keccak256(ASSET_SET_DOMAIN || RENDERER_ID || pageHash), with domain keccak256("sqk.dotgrid-asset-set.v1"). It differs from the root codehash and the page hash.

EventsLink to this section

The renderer and validator emit no events. SqueekNFT's BatchMetadataUpdate announces when readers should refresh metadata.

ErrorsLink to this section

Not every integer in a range is assigned. Token input checks run before any page read.

Integrator patternsLink to this section

• Render through SqueekNFT. Call SqueekNFT.tokenURI(id): it checks the NFT exists and uses the pinned page. The renderer alone renders any ID, which neither mints it nor proves ownership.
• Verify identities once, then cache. Rendering is deterministic for a given page, seed and ID; re-verify only after BatchMetadataUpdate.
• Compare keccak256, not file digests. Code and page hashes are keccak256; do not compare them with SHA-256 digests or a hosted raster image.
• Expect RPC limits. Rendering can exceed an RPC's eth_call gas or response limits even within DotGrid's own resolve-cost budget.
• Treat output as untrusted. Display the SVG as an isolated image, never as inline markup.

Verifying identitiesLink to this section

Read every value at one Ethereum block and compare it with the deployment record. A matching hash proves the bytes only if you trust the record.

1. Read SqueekNFT renderer(), art(), artCodehash(), sceneHash(), assetSetHash() and collectionSeed(). art is the page root address.
2. Compare keccak256 of the renderer's runtime code with the expected hash, and rendererId() with keccak256("sqk.dotgrid-renderer.v1").
3. Read the renderer's pageValidator() and compare its runtime hash separately.
4. Compare the root's runtime hash with artCodehash(); the root commits to its chunk hashes.
5. Call the renderer's validatePage(art) and require it to return sceneHash() and assetSetHash().
6. Require a nonzero seed, then render an existing ID through SqueekNFT.

LimitsLink to this section

The Squeeks page holds 25,800 logical bytes in one chunk.

Usage exampleLink to this section

Check the renderer, validator and page identities that SqueekNFT pinned.

// verify-art.ts
import { getAddress, keccak256, parseAbi, toBytes } from "viem";
import { blockNumber, client, required } from "./setup";

const nft = getAddress(required("NFT_ADDRESS"));
const nftAbi = parseAbi([
  "function renderer() view returns (address)",
  "function art() view returns (address)",
  "function artCodehash() view returns (bytes32)",
  "function sceneHash() view returns (bytes32)",
  "function assetSetHash() view returns (bytes32)",
  "function collectionSeed() view returns (bytes32)",
]);
const rendererAbi = parseAbi([
  "function rendererId() pure returns (bytes32)",
  "function pageValidator() view returns (address)",
  "function validatePage(address page) view returns (bytes32 pageHash, bytes32 assetSetHash)",
]);
const read = { address: nft, abi: nftAbi, blockNumber } as const;
const [renderer, art, artCodehash, sceneHash, assetSetHash, seed] = await Promise.all([
  client.readContract({ ...read, functionName: "renderer" }),
  client.readContract({ ...read, functionName: "art" }),
  client.readContract({ ...read, functionName: "artCodehash" }),
  client.readContract({ ...read, functionName: "sceneHash" }),
  client.readContract({ ...read, functionName: "assetSetHash" }),
  client.readContract({ ...read, functionName: "collectionSeed" }),
]);
const rendered = { address: renderer, abi: rendererAbi, blockNumber } as const;
const [rendererId, validator, [pageHash, assetSet]] = await Promise.all([
  client.readContract({ ...rendered, functionName: "rendererId" }),
  client.readContract({ ...rendered, functionName: "pageValidator" }),
  client.readContract({ ...rendered, functionName: "validatePage", args: [art] }),
]);
const codeHash = async (address: `0x${string}`) => keccak256((await client.getCode({ address, blockNumber })) ?? "0x");
const checks = {
  rendererId: rendererId === keccak256(toBytes("sqk.dotgrid-renderer.v1")),
  rootCode: (await codeHash(art)) === artCodehash,
  pageHash: pageHash === sceneHash,
  assetSet: assetSet === assetSetHash,
  seed: BigInt(seed) !== 0n,
};
if (Object.values(checks).includes(false)) throw new Error(`Art identity mismatch: ${JSON.stringify(checks)}`);
console.log({ renderer, rendererCode: await codeHash(renderer), validator, validatorCode: await codeHash(validator), art, pageHash });

Compare the printed renderer and validator code hashes with the values in your deployment record. To decode a Squeek's metadata, see the SqueekNFT usage example.

ABILink to this section

DotGridRenderer.json and DotGridPageValidator.json.

Related pagesLink to this section

• SqueekNFT
• Getting a Miner