{"sources":{"src/PodGenesis.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\nimport {ERC721} from \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport {Ownable, Ownable2Step} from \"@openzeppelin/contracts/access/Ownable2Step.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/utils/Pausable.sol\";\nimport {EIP712} from \"@openzeppelin/contracts/utils/cryptography/EIP712.sol\";\nimport {ECDSA} from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport {Stone} from \"./RuneRenderer.sol\";\n\n/// @notice The SPACE ID Agent ID registry on BSC (a wallet holds a .ai Agent ID when its balance is above zero).\ninterface IAgentId {\n function balanceOf(address owner) external view returns (uint256);\n}\n\n/// @notice Draws a token and returns its metadata URI (RuneRenderer).\ninterface IRenderer {\n function tokenURI(uint256 tokenId, Stone calldata s) external view returns (string memory);\n}\n\n/// @title PodGenesis\n/// @notice Proof of Difficulty, as runestones. Two tracks of `tiers` tiers of `tierSize` each:\n/// - solo: an agent solves a puzzle alone;\n/// - collaboration: an agent redeems solves made in teams of three.\n/// Every tier is twice the work of the one before. The verifier signs a mint authorization for the wallet that\n/// earned it. The contract holds each track's tiers to exactly `tierSize` mints and each wallet to its track's\n/// limit, so no tier can be oversold whatever the verifier signs. The first mint of each track and tier is\n/// marked as such here, not by the verifier.\ncontract PodGenesis is ERC721, Ownable2Step, Pausable, EIP712 {\n bytes32 public constant MINT_TYPEHASH = keccak256(\n \"MintAuth(address to,bytes32 attempt,uint8 track,uint8 tier,uint16 partners,uint16 successes,uint8 rank,uint256 deadline)\"\n );\n uint8 public constant SOLO = 0;\n uint8 public constant COLLAB = 1;\n\n uint256 public immutable tierSize;\n uint8 public immutable tiers;\n uint256 public immutable soloLimit;\n uint256 public immutable collabLimit;\n /// @notice The Agent ID registry checked at every mint; address(0) turns the check off (local tests only).\n IAgentId public immutable agentId;\n\n address public signer;\n IRenderer public renderer;\n bool public rendererFrozen;\n uint256 public totalMinted;\n mapping(bytes32 => bool) public attemptUsed;\n mapping(uint8 track => mapping(uint8 tier => uint256)) public mintedIn;\n mapping(uint8 track => mapping(address wallet => uint256)) public mintsOf;\n mapping(uint256 => Stone) private _stones;\n\n /// @notice What the verifier signs (with `to` = the minting wallet). partners, successes and rank are the\n /// collaboration counts at redemption, 0 for solo.\n struct Mint {\n bytes32 attempt;\n uint8 track;\n uint8 tier;\n uint16 partners;\n uint16 successes;\n uint8 rank;\n uint256 deadline;\n }\n\n event Minted(address indexed to, uint256 indexed tokenId, uint8 track, uint8 tier, bool first, bytes32 indexed attempt);\n event SignerSet(address signer);\n event RendererSet(address renderer);\n event RendererFrozen();\n\n error ZeroAddress();\n error Expired();\n error BadSignature();\n error AttemptUsed();\n error NoSuchTrack();\n error NoSuchTier();\n error TierFull();\n error WalletLimit();\n error NoAgentId();\n error Frozen();\n\n constructor(string memory name_, string memory symbol_, uint256 tierSize_, uint8 tiers_, uint256 soloLimit_, uint256 collabLimit_,\n IAgentId agentId_, address signer_, IRenderer renderer_, address owner_)\n ERC721(name_, symbol_) Ownable(owner_) EIP712(\"PodGenesis\", \"1\")\n {\n if (signer_ == address(0) || address(renderer_) == address(0)) revert ZeroAddress();\n tierSize = tierSize_;\n tiers = tiers_;\n soloLimit = soloLimit_;\n collabLimit = collabLimit_;\n agentId = agentId_;\n signer = signer_;\n renderer = renderer_;\n emit SignerSet(signer_);\n emit RendererSet(address(renderer_));\n }\n\n /// @notice Mints one runestone to msg.sender with the verifier's authorization.\n function mint(Mint calldata a, bytes calldata signature) external whenNotPaused returns (uint256 tokenId) {\n if (block.timestamp > a.deadline) revert Expired();\n bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(MINT_TYPEHASH, msg.sender, a.attempt, a.track, a.tier, a.partners,\n a.successes, a.rank, a.deadline)));\n if (ECDSA.recover(digest, signature) != signer) revert BadSignature();\n if (attemptUsed[a.attempt]) revert AttemptUsed();\n if (a.track > COLLAB) revert NoSuchTrack();\n if (a.tier >= tiers) revert NoSuchTier();\n uint256 inTier = mintedIn[a.track][a.tier];\n if (inTier >= tierSize) revert TierFull();\n if (mintsOf[a.track][msg.sender] >= walletLimit(a.track)) revert WalletLimit();\n if (address(agentId) != address(0) && agentId.balanceOf(msg.sender) == 0) revert NoAgentId();\n\n attemptUsed[a.attempt] = true;\n mintedIn[a.track][a.tier] = inTier + 1;\n mintsOf[a.track][msg.sender] += 1;\n tokenId = ++totalMinted;\n _stones[tokenId] = Stone(a.track, a.tier, inTier == 0, a.partners, a.successes, a.rank, a.attempt);\n _safeMint(msg.sender, tokenId);\n emit Minted(msg.sender, tokenId, a.track, a.tier, inTier == 0, a.attempt);\n }\n\n function walletLimit(uint8 track) public view returns (uint256) {\n return track == SOLO ? soloLimit : collabLimit;\n }\n\n function maxSupply() external view returns (uint256) {\n return tierSize * tiers * 2;\n }\n\n function stoneOf(uint256 tokenId) external view returns (Stone memory) {\n _requireOwned(tokenId);\n return _stones[tokenId];\n }\n\n /// @notice On-chain metadata and art: a runestone drawn by the renderer, as a data URI.\n function tokenURI(uint256 tokenId) public view override returns (string memory) {\n _requireOwned(tokenId);\n return renderer.tokenURI(tokenId, _stones[tokenId]);\n }\n\n function setSigner(address signer_) external onlyOwner {\n if (signer_ == address(0)) revert ZeroAddress();\n signer = signer_;\n emit SignerSet(signer_);\n }\n\n /// @notice Replaces the renderer (a fix to the art), until the owner freezes it for good.\n function setRenderer(IRenderer renderer_) external onlyOwner {\n if (rendererFrozen) revert Frozen();\n if (address(renderer_) == address(0)) revert ZeroAddress();\n renderer = renderer_;\n emit RendererSet(address(renderer_));\n }\n\n function freezeRenderer() external onlyOwner {\n rendererFrozen = true;\n emit RendererFrozen();\n }\n\n function pause() external onlyOwner { _pause(); }\n function unpause() external onlyOwner { _unpause(); }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.24;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {ERC721Utils} from \"./utils/ERC721Utils.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n using Strings for uint256;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n mapping(uint256 tokenId => address) private _owners;\n\n mapping(address owner => uint256) private _balances;\n\n mapping(uint256 tokenId => address) private _tokenApprovals;\n\n mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n /**\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n */\n constructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /// @inheritdoc IERC165\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n return\n interfaceId == type(IERC721).interfaceId ||\n interfaceId == type(IERC721Metadata).interfaceId ||\n super.supportsInterface(interfaceId);\n }\n\n /// @inheritdoc IERC721\n function balanceOf(address owner) public view virtual returns (uint256) {\n if (owner == address(0)) {\n revert ERC721InvalidOwner(address(0));\n }\n return _balances[owner];\n }\n\n /// @inheritdoc IERC721\n function ownerOf(uint256 tokenId) public view virtual returns (address) {\n return _requireOwned(tokenId);\n }\n\n /// @inheritdoc IERC721Metadata\n function name() public view virtual returns (string memory) {\n return _name;\n }\n\n /// @inheritdoc IERC721Metadata\n function symbol() public view virtual returns (string memory) {\n return _symbol;\n }\n\n /// @inheritdoc IERC721Metadata\n function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n _requireOwned(tokenId);\n\n string memory baseURI = _baseURI();\n return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n }\n\n /**\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n * by default, can be overridden in child contracts.\n */\n function _baseURI() internal view virtual returns (string memory) {\n return \"\";\n }\n\n /// @inheritdoc IERC721\n function approve(address to, uint256 tokenId) public virtual {\n _approve(to, tokenId, _msgSender());\n }\n\n /// @inheritdoc IERC721\n function getApproved(uint256 tokenId) public view virtual returns (address) {\n _requireOwned(tokenId);\n\n return _getApproved(tokenId);\n }\n\n /// @inheritdoc IERC721\n function setApprovalForAll(address operator, bool approved) public virtual {\n _setApprovalForAll(_msgSender(), operator, approved);\n }\n\n /// @inheritdoc IERC721\n function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /// @inheritdoc IERC721\n function transferFrom(address from, address to, uint256 tokenId) public virtual {\n if (to == address(0)) {\n revert ERC721InvalidReceiver(address(0));\n }\n // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n address previousOwner = _update(to, tokenId, _msgSender());\n if (previousOwner != from) {\n revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n }\n }\n\n /// @inheritdoc IERC721\n function safeTransferFrom(address from, address to, uint256 tokenId) public {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /// @inheritdoc IERC721\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n transferFrom(from, to, tokenId);\n ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n }\n\n /**\n * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n *\n * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n */\n function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n return _owners[tokenId];\n }\n\n /**\n * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n */\n function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n return _tokenApprovals[tokenId];\n }\n\n /**\n * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n * particular (ignoring whether it is owned by `owner`).\n *\n * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n * assumption.\n */\n function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n return\n spender != address(0) &&\n (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n }\n\n /**\n * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n * Reverts if:\n * - `spender` does not have approval from `owner` for `tokenId`.\n * - `spender` does not have approval to manage all of `owner`'s assets.\n *\n * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n * assumption.\n */\n function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n if (!_isAuthorized(owner, spender, tokenId)) {\n if (owner == address(0)) {\n revert ERC721NonexistentToken(tokenId);\n } else {\n revert ERC721InsufficientApproval(spender, tokenId);\n }\n }\n }\n\n /**\n * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n *\n * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n *\n * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n * remain consistent with one another.\n */\n function _increaseBalance(address account, uint128 value) internal virtual {\n unchecked {\n _balances[account] += value;\n }\n }\n\n /**\n * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n *\n * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n *\n * Emits a {Transfer} event.\n *\n * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n */\n function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n address from = _ownerOf(tokenId);\n\n // Perform (optional) operator check\n if (auth != address(0)) {\n _checkAuthorized(from, auth, tokenId);\n }\n\n // Execute the update\n if (from != address(0)) {\n // Clear approval. No need to re-authorize or emit the Approval event\n _approve(address(0), tokenId, address(0), false);\n\n unchecked {\n _balances[from] -= 1;\n }\n }\n\n if (to != address(0)) {\n unchecked {\n _balances[to] += 1;\n }\n }\n\n _owners[tokenId] = to;\n\n emit Transfer(from, to, tokenId);\n\n return from;\n }\n\n /**\n * @dev Mints `tokenId` and transfers it to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n *\n * Emits a {Transfer} event.\n */\n function _mint(address to, uint256 tokenId) internal {\n if (to == address(0)) {\n revert ERC721InvalidReceiver(address(0));\n }\n address previousOwner = _update(to, tokenId, address(0));\n if (previousOwner != address(0)) {\n revert ERC721InvalidSender(address(0));\n }\n }\n\n /**\n * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeMint(address to, uint256 tokenId) internal {\n _safeMint(to, tokenId, \"\");\n }\n\n /**\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n */\n function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n _mint(to, tokenId);\n ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);\n }\n\n /**\n * @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n * This is an internal function that does not check if the sender is authorized to operate on the token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n *\n * Emits a {Transfer} event.\n */\n function _burn(uint256 tokenId) internal {\n address previousOwner = _update(address(0), tokenId, address(0));\n if (previousOwner == address(0)) {\n revert ERC721NonexistentToken(tokenId);\n }\n }\n\n /**\n * @dev Transfers `tokenId` from `from` to `to`.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n *\n * Emits a {Transfer} event.\n */\n function _transfer(address from, address to, uint256 tokenId) internal {\n if (to == address(0)) {\n revert ERC721InvalidReceiver(address(0));\n }\n address previousOwner = _update(to, tokenId, address(0));\n if (previousOwner == address(0)) {\n revert ERC721NonexistentToken(tokenId);\n } else if (previousOwner != from) {\n revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n }\n }\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n * are aware of the ERC-721 standard to prevent tokens from being forever locked.\n *\n * `data` is additional data, it has no specified format and it is sent in call to `to`.\n *\n * This internal function is like {safeTransferFrom} in the sense that it invokes\n * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n * implement alternative mechanisms to perform token transfer, such as signature-based.\n *\n * Requirements:\n *\n * - `tokenId` token must exist and be owned by `from`.\n * - `to` cannot be the zero address.\n * - `from` cannot be the zero address.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeTransfer(address from, address to, uint256 tokenId) internal {\n _safeTransfer(from, to, tokenId, \"\");\n }\n\n /**\n * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n */\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n _transfer(from, to, tokenId);\n ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n }\n\n /**\n * @dev Approve `to` to operate on `tokenId`\n *\n * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n * either the owner of the token, or approved to operate on all tokens held by this owner.\n *\n * Emits an {Approval} event.\n *\n * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n */\n function _approve(address to, uint256 tokenId, address auth) internal {\n _approve(to, tokenId, auth, true);\n }\n\n /**\n * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n * emitted in the context of transfers.\n */\n function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n // Avoid reading the owner unless necessary\n if (emitEvent || auth != address(0)) {\n address owner = _requireOwned(tokenId);\n\n // We do not use _isAuthorized because single-token approvals should not be able to call approve\n if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n revert ERC721InvalidApprover(auth);\n }\n\n if (emitEvent) {\n emit Approval(owner, to, tokenId);\n }\n }\n\n _tokenApprovals[tokenId] = to;\n }\n\n /**\n * @dev Approve `operator` to operate on all of `owner` tokens\n *\n * Requirements:\n * - operator can't be the address zero.\n *\n * Emits an {ApprovalForAll} event.\n */\n function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n if (owner == address(0)) {\n revert ERC721InvalidApprover(address(0));\n }\n if (operator == address(0)) {\n revert ERC721InvalidOperator(operator);\n }\n _operatorApprovals[owner][operator] = approved;\n emit ApprovalForAll(owner, operator, approved);\n }\n\n /**\n * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n * Returns the owner.\n *\n * Overrides to ownership logic should be done to {_ownerOf}.\n */\n function _requireOwned(uint256 tokenId) internal view returns (address) {\n address owner = _ownerOf(tokenId);\n if (owner == address(0)) {\n revert ERC721NonexistentToken(tokenId);\n }\n return owner;\n }\n}\n"},"lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n address private _pendingOwner;\n\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Returns the address of the pending owner.\n */\n function pendingOwner() public view virtual returns (address) {\n return _pendingOwner;\n }\n\n /**\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n * Can only be called by the current owner.\n *\n * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n */\n function transferOwnership(address newOwner) public virtual override onlyOwner {\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(owner(), newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual override {\n delete _pendingOwner;\n super._transferOwnership(newOwner);\n }\n\n /**\n * @dev The new owner accepts the ownership transfer.\n */\n function acceptOwnership() public virtual {\n address sender = _msgSender();\n if (pendingOwner() != sender) {\n revert OwnableUnauthorizedAccount(sender);\n }\n _transferOwnership(sender);\n }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n bool private _paused;\n\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n /**\n * @dev The operation failed because the contract is paused.\n */\n error EnforcedPause();\n\n /**\n * @dev The operation failed because the contract is not paused.\n */\n error ExpectedPause();\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n if (paused()) {\n revert EnforcedPause();\n }\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n if (!paused()) {\n revert ExpectedPause();\n }\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n _paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n _paused = false;\n emit Unpaused(_msgSender());\n }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/EIP712.sol)\n\npragma solidity ^0.8.24;\n\nimport {MessageHashUtils} from \"./MessageHashUtils.sol\";\nimport {ShortStrings, ShortString} from \"../ShortStrings.sol\";\nimport {IERC5267} from \"../../interfaces/IERC5267.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\n * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\n *\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\n */\nabstract contract EIP712 is IERC5267 {\n using ShortStrings for *;\n\n bytes32 private constant TYPE_HASH =\n keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n // invalidate the cached domain separator if the chain id changes.\n bytes32 private immutable _cachedDomainSeparator;\n uint256 private immutable _cachedChainId;\n address private immutable _cachedThis;\n\n bytes32 private immutable _hashedName;\n bytes32 private immutable _hashedVersion;\n\n ShortString private immutable _name;\n ShortString private immutable _version;\n // slither-disable-next-line constable-states\n string private _nameFallback;\n // slither-disable-next-line constable-states\n string private _versionFallback;\n\n /**\n * @dev Initializes the domain separator and parameter caches.\n *\n * The meaning of `name` and `version` is specified in\n * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:\n *\n * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n * - `version`: the current major version of the signing domain.\n *\n * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n * contract upgrade].\n */\n constructor(string memory name, string memory version) {\n _name = name.toShortStringWithFallback(_nameFallback);\n _version = version.toShortStringWithFallback(_versionFallback);\n _hashedName = keccak256(bytes(name));\n _hashedVersion = keccak256(bytes(version));\n\n _cachedChainId = block.chainid;\n _cachedDomainSeparator = _buildDomainSeparator();\n _cachedThis = address(this);\n }\n\n /**\n * @dev Returns the domain separator for the current chain.\n */\n function _domainSeparatorV4() internal view returns (bytes32) {\n if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n return _cachedDomainSeparator;\n } else {\n return _buildDomainSeparator();\n }\n }\n\n function _buildDomainSeparator() private view returns (bytes32) {\n return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n }\n\n /**\n * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n * function returns the hash of the fully encoded EIP712 message for this domain.\n *\n * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n *\n * ```solidity\n * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n * keccak256(\"Mail(address to,string contents)\"),\n * mailTo,\n * keccak256(bytes(mailContents))\n * )));\n * address signer = ECDSA.recover(digest, signature);\n * ```\n */\n function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n }\n\n /// @inheritdoc IERC5267\n function eip712Domain()\n public\n view\n virtual\n returns (\n bytes1 fields,\n string memory name,\n string memory version,\n uint256 chainId,\n address verifyingContract,\n bytes32 salt,\n uint256[] memory extensions\n )\n {\n return (\n hex\"0f\", // 01111\n _EIP712Name(),\n _EIP712Version(),\n block.chainid,\n address(this),\n bytes32(0),\n new uint256[](0)\n );\n }\n\n /**\n * @dev The name parameter for the EIP712 domain.\n *\n * NOTE: By default this function reads _name which is an immutable value.\n * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n */\n // solhint-disable-next-line func-name-mixedcase\n function _EIP712Name() internal view returns (string memory) {\n return _name.toStringWithFallback(_nameFallback);\n }\n\n /**\n * @dev The version parameter for the EIP712 domain.\n *\n * NOTE: By default this function reads _version which is an immutable value.\n * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n */\n // solhint-disable-next-line func-name-mixedcase\n function _EIP712Version() internal view returns (string memory) {\n return _version.toStringWithFallback(_versionFallback);\n }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n enum RecoverError {\n NoError,\n InvalidSignature,\n InvalidSignatureLength,\n InvalidSignatureS\n }\n\n /**\n * @dev The signature is invalid.\n */\n error ECDSAInvalidSignature();\n\n /**\n * @dev The signature has an invalid length.\n */\n error ECDSAInvalidSignatureLength(uint256 length);\n\n /**\n * @dev The signature has an S value that is in the upper half order.\n */\n error ECDSAInvalidSignatureS(bytes32 s);\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n * and a bytes32 providing additional information about the error.\n *\n * If no error is returned, then the address can be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n * invalidation or nonces for replay protection.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n *\n * Documentation for signature generation:\n *\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n */\n function tryRecover(\n bytes32 hash,\n bytes memory signature\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly (\"memory-safe\") {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n return tryRecover(hash, v, r, s);\n } else {\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n }\n }\n\n /**\n * @dev Variant of {tryRecover} that takes a signature in calldata\n */\n function tryRecoverCalldata(\n bytes32 hash,\n bytes calldata signature\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, calldata slices would work here, but are\n // significantly more expensive (length check) than using calldataload in assembly.\n assembly (\"memory-safe\") {\n r := calldataload(signature.offset)\n s := calldataload(add(signature.offset, 0x20))\n v := byte(0, calldataload(add(signature.offset, 0x40)))\n }\n return tryRecover(hash, v, r, s);\n } else {\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n }\n }\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n * invalidation or nonces for replay protection.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Variant of {recover} that takes a signature in calldata\n */\n function recoverCalldata(bytes32 hash, bytes calldata signature) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecoverCalldata(hash, signature);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n *\n * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n */\n function tryRecover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n unchecked {\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n // We do not check for an overflow here since the shift operation results in 0 or 1.\n uint8 v = uint8((uint256(vs) >> 255) + 27);\n return tryRecover(hash, v, r, s);\n }\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately.\n */\n function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function tryRecover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n return (address(0), RecoverError.InvalidSignatureS, s);\n }\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n if (signer == address(0)) {\n return (address(0), RecoverError.InvalidSignature, bytes32(0));\n }\n\n return (signer, RecoverError.NoError, bytes32(0));\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Parse a signature into its `v`, `r` and `s` components. Supports 65-byte and 64-byte (ERC-2098)\n * formats. Returns (0,0,0) for invalid signatures.\n *\n * For 64-byte signatures, `v` is automatically normalized to 27 or 28.\n * For 65-byte signatures, `v` is returned as-is and MUST already be 27 or 28 for use with ecrecover.\n *\n * Consider validating the result before use, or use {tryRecover}/{recover} which perform full validation.\n */\n function parse(bytes memory signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n assembly (\"memory-safe\") {\n // Check the signature length\n switch mload(signature)\n // - case 65: r,s,v signature (standard)\n case 65 {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n case 64 {\n let vs := mload(add(signature, 0x40))\n r := mload(add(signature, 0x20))\n s := and(vs, shr(1, not(0)))\n v := add(shr(255, vs), 27)\n }\n default {\n r := 0\n s := 0\n v := 0\n }\n }\n }\n\n /**\n * @dev Variant of {parse} that takes a signature in calldata\n */\n function parseCalldata(bytes calldata signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n assembly (\"memory-safe\") {\n // Check the signature length\n switch signature.length\n // - case 65: r,s,v signature (standard)\n case 65 {\n r := calldataload(signature.offset)\n s := calldataload(add(signature.offset, 0x20))\n v := byte(0, calldataload(add(signature.offset, 0x40)))\n }\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n case 64 {\n let vs := calldataload(add(signature.offset, 0x20))\n r := calldataload(signature.offset)\n s := and(vs, shr(1, not(0)))\n v := add(shr(255, vs), 27)\n }\n default {\n r := 0\n s := 0\n v := 0\n }\n }\n }\n\n /**\n * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n */\n function _throwError(RecoverError error, bytes32 errorArg) private pure {\n if (error == RecoverError.NoError) {\n return; // no error: do nothing\n } else if (error == RecoverError.InvalidSignature) {\n revert ECDSAInvalidSignature();\n } else if (error == RecoverError.InvalidSignatureLength) {\n revert ECDSAInvalidSignatureLength(uint256(errorArg));\n } else if (error == RecoverError.InvalidSignatureS) {\n revert ECDSAInvalidSignatureS(errorArg);\n }\n }\n}\n"},"src/RuneRenderer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\nimport {Base64} from \"@openzeppelin/contracts/utils/Base64.sol\";\nimport {Strings} from \"@openzeppelin/contracts/utils/Strings.sol\";\nimport {RuneData as D} from \"./RuneData.sol\";\n\n/// @notice What a token carries for its art and metadata.\nstruct Stone {\n uint8 track; // 0 solo, 1 collaboration\n uint8 tier;\n bool first; // the first mint of its track and tier\n uint16 partners; // collaboration: distinct agents solved with\n uint16 successes; // collaboration: solves when redeemed\n uint8 rank; // collaboration: the wallet's first, second or third\n bytes32 seed; // the attempt it was minted with\n}\n\n/// @notice What every part of the renderer shares: the buffer, numbers, the sine table, random numbers, and the parts\n/// of a stone (definitions, frame, outline, faces, carved runes, captions). Integers only, step for step as in\n/// the reference renderer art/runes.js: lengths in tenths of a pixel on a 1000 x 1000 canvas, angles in whole\n/// degrees with a sine table scaled by 10000, divisions truncating toward zero, random numbers\n/// keccak256(seed, tokenId, counter).\nabstract contract RuneKit {\n using Strings for uint256;\n\n struct Buf { bytes b; uint256 n; }\n struct Ctx { bytes sinT; bytes32 seed; uint256 tokenId; uint256 i; uint256 ids; }\n struct Mat { bytes s0; bytes s1; bytes edge; bytes glow; }\n struct Carve { int256 cx; int256 cy; int256 h; int256 width; bytes color; bytes glow; bytes halo; }\n /// The bound stone's geometry: crack angles, the rim, each crack's rim vertex and its seven points.\n struct Geo { int256[] cracks; int256[] ra; int256[] rx; int256[] ry; uint256[3] at; int256[7][3] lx; int256[7][3] ly; }\n\n bytes internal constant DOT = hex\"20c2b720\"; // \" · \"\n uint256 internal constant GEBO = 6;\n uint256 internal constant ISA = 10;\n\n function _defs(Buf memory w, Mat memory m, bool first, uint256 tex) internal pure {\n _s(w, '');\n _put(w, stars);\n _s(w, '');\n uint256[] memory one = new uint256[](1);\n for (uint256 i = 0; i < 24; i++) {\n int256 a = 270 + 15 * int256(i);\n int256 x = 5000 + _cos(c, a) * 4360 / 10000;\n int256 y = 5000 + _sin(c, a) * 4360 / 10000;\n _s(w, '');\n one[0] = i;\n _strokes(w, one, x, y, 30);\n _s(w, \" \");\n }\n _s(w, ' ');\n for (uint256 i = 0; i < 8; i++) {\n int256 x = 300 * int256(i) + 3950;\n bool on = i <= tier;\n _s(w, '');\n }\n }\n\n function _stars(Ctx memory c, uint256 tier) internal pure returns (bytes memory) {\n if (tier != 7) return \"\";\n Buf memory w = _new(6000);\n for (uint256 i = 0; i < 70; i++) {\n int256 x = _rnd(c, 10000);\n int256 y = _rnd(c, 8600);\n int256 r = 5 + _rnd(c, 18);\n int256 o = 15 + _rnd(c, 55);\n _s(w, '');\n if (tint.length > 0) { _put(w, u); _s(w, 'fill=\"'); _put(w, tint); _s(w, '\"/>'); }\n _put(w, u); _s(w, 'fill=\"#000\" opacity=\"0.55\" filter=\"url(#strata)\"/>');\n _put(w, u); _s(w, 'fill=\"#fff\" opacity=\"0.07\" filter=\"url(#grain)\"/>');\n _put(w, u); _s(w, 'fill=\"url(#sheen)\"/>');\n _put(w, u); _s(w, 'fill=\"none\" stroke=\"url(#bevel)\" stroke-width=\"9\" stroke-linejoin=\"round\"/>');\n }\n\n function _strokes(Buf memory w, uint256[] memory runes, int256 cx, int256 cy, int256 h) internal pure {\n for (uint256 r = 0; r < runes.length; r++) _rune(w, runes[r], cx - 3 * h, cy - 5 * h, h);\n }\n\n function _rune(Buf memory w, uint256 rune, int256 x0, int256 y0, int256 h) internal pure {\n bytes memory S = D.STROKES;\n uint256 p = _u16(D.STROKE_OFF, rune);\n uint256 ns = uint8(S[p++]);\n for (uint256 st = 0; st < ns; st++) {\n uint256 np = uint8(S[p++]);\n _s(w, ' 0) _s(w, \" \");\n int256 x = int256(uint256(uint8(S[p++])));\n int256 y = int256(uint256(uint8(S[p++])));\n _pt(w, x0 + x * h / 10, y0 + y * h / 10);\n }\n _s(w, '\"/>');\n }\n }\n\n function _u16(bytes memory b, uint256 i) internal pure returns (uint256) {\n return (uint256(uint8(b[2 * i])) << 8) | uint8(b[2 * i + 1]);\n }\n\n function _carve(Buf memory w, Ctx memory c, uint256[] memory runes, Carve memory a) internal pure {\n bytes memory id = bytes(c.ids.toString());\n c.ids++;\n int256 d = a.width * 12 / 100;\n if (d < 10) d = 10;\n _s(w, '');\n _strokes(w, runes, a.cx, a.cy, a.h);\n _s(w, ' ');\n bytes memory u = abi.encodePacked(''); _put(w, u);\n _s(w, ' '); _put(w, u);\n _s(w, ' '); _put(w, u);\n _s(w, ' '); _put(w, u);\n _s(w, ' '); _put(w, u); _s(w, \" \");\n }\n\n function _caption(Buf memory w, bytes memory a, bytes memory b) internal pure {\n _s(w, '');\n _put(w, a);\n _s(w, ' ');\n _put(w, b);\n _s(w, \" \");\n }\n\n function _mat(uint256 tier) internal pure returns (Mat memory) {\n bytes memory C = D.COLORS;\n uint256 o = tier * 28;\n return Mat(_slice(C, o, 7), _slice(C, o + 7, 7), _slice(C, o + 14, 7), _slice(C, o + 21, 7));\n }\n\n function _str(bytes memory blob, bytes memory off, uint256 i) internal pure returns (bytes memory) {\n uint256 a = _u16(off, i);\n return _slice(blob, a, _u16(off, i + 1) - a);\n }\n\n function _slice(bytes memory b, uint256 start, uint256 len) internal pure returns (bytes memory r) {\n r = new bytes(len);\n assembly { mcopy(add(r, 32), add(add(b, 32), start), len) }\n }\n\n function _upper(bytes memory s) internal pure returns (bytes memory r) {\n r = new bytes(s.length);\n for (uint256 i = 0; i < s.length; i++) {\n bytes1 ch = s[i];\n r[i] = ch >= 0x61 && ch <= 0x7a ? bytes1(uint8(ch) - 32) : ch;\n }\n }\n\n function _rnd(Ctx memory c, uint256 n) internal pure returns (int256) {\n return int256(uint256(keccak256(abi.encodePacked(c.seed, c.tokenId, c.i++))) % n);\n }\n\n function _sin(Ctx memory c, int256 d) internal pure returns (int256 v) {\n uint256 i = uint256(((d % 360) + 360) % 360);\n bytes memory t = c.sinT;\n assembly { v := signextend(1, shr(240, mload(add(add(t, 32), mul(i, 2))))) }\n }\n\n function _cos(Ctx memory c, int256 d) internal pure returns (int256) {\n return _sin(c, d + 90);\n }\n\n function _norm(int256 d) internal pure returns (int256) {\n return (((d + 90) % 360) + 360) % 360 - 90;\n }\n\n function _new(uint256 cap) internal pure returns (Buf memory w) {\n w.b = new bytes(cap);\n }\n\n function _put(Buf memory w, bytes memory s) internal pure {\n uint256 n = w.n;\n uint256 m = n + s.length;\n if (m > w.b.length) {\n uint256 cap = w.b.length * 2;\n if (cap < m) cap = m * 2;\n bytes memory nb = new bytes(cap);\n bytes memory ob = w.b;\n assembly { mcopy(add(nb, 32), add(ob, 32), n) }\n w.b = nb;\n }\n bytes memory b = w.b;\n assembly { mcopy(add(add(b, 32), n), add(s, 32), mload(s)) }\n w.n = m;\n }\n\n function _s(Buf memory w, string memory s) internal pure {\n _put(w, bytes(s));\n }\n\n /// Tenths as text: 1234 -> \"123.4\", 1230 -> \"123\", -5 -> \"-0.5\".\n function _f(Buf memory w, int256 t) internal pure {\n uint256 a;\n if (t < 0) { _s(w, \"-\"); a = uint256(-t); } else { a = uint256(t); }\n _s(w, (a / 10).toString());\n if (a % 10 != 0) { _s(w, \".\"); _s(w, (a % 10).toString()); }\n }\n\n function _pt(Buf memory w, int256 x, int256 y) internal pure {\n _f(w, x); _s(w, \",\"); _f(w, y);\n }\n\n function _done(Buf memory w) internal pure returns (bytes memory b) {\n b = w.b;\n uint256 n = w.n;\n assembly { mstore(b, n) }\n }\n}\n\n/// @title SoloArt\n/// @notice The solo track's runestone: one stone carved with its tier's rune of Freyr's aett (Tyr's for the first).\ncontract SoloArt is RuneKit {\n using Strings for uint256;\n\n function svg(uint256 tokenId, Stone calldata s) external pure returns (bytes memory) {\n Ctx memory c = Ctx(D.SIN, s.seed, tokenId, 0, 0);\n Buf memory w = _new(16000);\n _solo(w, c, s);\n return _done(w);\n }\n\n function _solo(Buf memory w, Ctx memory c, Stone calldata s) private pure {\n Mat memory m = _mat(s.tier);\n uint256 main = s.first ? 16 + s.tier : s.tier;\n uint256 tex = uint256(_rnd(c, 999));\n int256[] memory none = new int256[](0);\n (, int256[] memory xs, int256[] memory ys) = _outline(c, 5000, 4700, 2700, 3350, none);\n bytes memory d = _smooth(xs, ys);\n bytes memory stars = _stars(c, s.tier);\n _s(w, '');\n _defs(w, m, s.first, tex);\n _frame(w, c, m, s.tier, stars);\n if (s.first) {\n _s(w, '');\n for (int256 i = 0; i < 36; i++) {\n int256 a = 10 * i;\n _s(w, ' \");\n }\n _s(w, '');\n _face(w, c, d, \"\");\n uint256[] memory runes = new uint256[](1);\n runes[0] = main;\n _carve(w, c, runes, Carve(5000, 4700, 360, s.first ? int256(230) : int256(190), s.first ? bytes(\"#ffd45a\") : m.glow,\n s.first ? bytes(\"#ff5a1f\") : m.glow, \"0.55\"));\n Buf memory a = _new(64);\n _put(a, _upper(_str(D.NAMES, D.NAME_OFF, main))); _put(a, DOT); _put(a, _upper(_str(D.MEANINGS, D.MEANING_OFF, main)));\n Buf memory b = _new(96);\n _s(b, s.first ? \"FIRST TO OPEN\" : \"RUNESTONE\"); _put(b, DOT); _s(b, \"TIER \"); _put(b, _str(D.ROMAN, D.ROMAN_OFF, s.tier));\n _put(b, DOT); _s(b, \"NO. \"); _s(b, c.tokenId.toString());\n _caption(w, _done(a), _done(b));\n _s(w, \" \");\n }\n}\n\n/// @title BoundArt\n/// @notice The collaboration track's bound stone: one stone in three pieces held apart by light, the bind rune across\n/// all three, a pebble tied by light for every partner, and the valknut behind.\ncontract BoundArt is RuneKit {\n using Strings for uint256;\n\n function svg(uint256 tokenId, Stone calldata s) external pure returns (bytes memory) {\n Ctx memory c = Ctx(D.SIN, s.seed, tokenId, 0, 0);\n Buf memory w = _new(40000);\n _bound(w, c, s);\n return _done(w);\n }\n\n function _bound(Buf memory w, Ctx memory c, Stone calldata s) private pure {\n Mat memory m = _mat(s.tier);\n uint256 main = s.first ? 16 + s.tier : 8 + s.tier;\n uint256 tex = uint256(_rnd(c, 999));\n Geo memory g = _geo(c);\n bytes memory pieces = _pieces(c, m, g);\n Buf memory seams = _new(1200);\n for (uint256 k = 0; k < 3; k++) {\n _s(seams, ' 0) _s(seams, \" \"); _pt(seams, g.lx[k][i], g.ly[k][i]); }\n _s(seams, '\"/>');\n }\n (bytes memory threads, bytes memory pebbles) = _pebbles(c, m, s.partners);\n bytes memory stars = _stars(c, s.tier);\n bytes memory lit = s.first ? bytes(\"#ffd45a\") : m.glow;\n\n _s(w, '');\n _defs(w, m, s.first, tex);\n _frame(w, c, m, s.tier, stars);\n _s(w, ''); _valknut(w, c); _s(w, \" \");\n _s(w, '');\n _s(w, ''); _put(w, threads); _s(w, \" \");\n _s(w, '');\n _put(w, threads); _s(w, \" \"); _put(w, pebbles);\n _s(w, '');\n bytes memory sm = _done(seams);\n _s(w, ''); _put(w, sm);\n _s(w, ' '); _put(w, sm);\n _s(w, ' '); _put(w, sm); _s(w, \" \");\n }\n\n /// The centre point, the three cracks and the rim; each crack a jagged line of 7 points from the centre point out\n /// to its rim vertex.\n function _geo(Ctx memory c) private pure returns (Geo memory g) {\n int256 ox = 5000 + _rnd(c, 241) - 120;\n int256 oy = 4880 + _rnd(c, 201) - 100;\n g.cracks = new int256[](3);\n g.cracks[0] = _norm(255 + _rnd(c, 31));\n g.cracks[1] = _norm(15 + _rnd(c, 31));\n g.cracks[2] = _norm(135 + _rnd(c, 31));\n (g.ra, g.rx, g.ry) = _outline(c, 5000, 4700, 2700, 3350, g.cracks);\n for (uint256 k = 0; k < 3; k++) {\n int256 a = g.cracks[k];\n g.at[k] = _at(g.ra, a);\n int256 ex = g.rx[g.at[k]];\n int256 ey = g.ry[g.at[k]];\n g.lx[k][0] = ox;\n g.ly[k][0] = oy;\n for (int256 i = 1; i <= 5; i++) {\n int256 j = _rnd(c, 261) - 130;\n g.lx[k][uint256(i)] = ox + (ex - ox) * i / 6 + _cos(c, a + 90) * j / 10000;\n g.ly[k][uint256(i)] = oy + (ey - oy) * i / 6 + _sin(c, a + 90) * j / 10000;\n }\n g.lx[k][6] = ex;\n g.ly[k][6] = ey;\n }\n }\n\n /// The three pieces, in rim order, each moved a little out along the middle of its arc, with its aett's mark.\n function _pieces(Ctx memory c, Mat memory m, Geo memory g) private pure returns (bytes memory) {\n uint256[3] memory at = g.at;\n uint256 rimLen = g.ra.length;\n uint256[3] memory order = [uint256(0), 1, 2];\n for (uint256 i = 1; i < 3; i++) {\n for (uint256 j = i; j > 0 && at[order[j - 1]] > at[order[j]]; j--) (order[j - 1], order[j]) = (order[j], order[j - 1]);\n }\n Buf memory w = _new(9000);\n for (uint256 k = 0; k < 3; k++) {\n uint256 ci = order[k];\n uint256 cj = order[(k + 1) % 3];\n Buf memory p = _new(1600);\n _s(p, \"M\");\n for (uint256 i = 0; i < 7; i++) { if (i > 0) _s(p, \" L\"); _pt(p, g.lx[ci][i], g.ly[ci][i]); }\n for (uint256 i = (at[ci] + 1) % rimLen; i != at[cj]; i = (i + 1) % rimLen) { _s(p, \" L\"); _pt(p, g.rx[i], g.ry[i]); }\n for (uint256 i = 7; i > 0; i--) { _s(p, \" L\"); _pt(p, g.lx[cj][i - 1], g.ly[cj][i - 1]); }\n _s(p, \" Z\");\n int256 mid = g.cracks[ci] + ((g.cracks[cj] - g.cracks[ci] + 360) % 360) / 2;\n int256 dx = _cos(c, mid) * 90 / 10000;\n int256 dy = _sin(c, mid) * 90 / 10000;\n _s(w, '');\n _face(w, c, _done(p), k == 0 ? bytes(\"#ffffff0a\") : k == 1 ? bytes(\"#00000014\") : bytes(\"#ffffff04\"));\n _s(w, \" \");\n uint256[] memory mark = new uint256[](1);\n mark[0] = k == 0 ? 0 : k == 1 ? 8 : 16; // Fehu, Hagalaz, Tiwaz: the first rune of each aett\n _carve(w, c, mark, Carve(5000 + _cos(c, mid) * 1750 / 10000 + dx, 4700 + _sin(c, mid) * 2150 / 10000 + dy, 46, 55, m.glow, m.glow, \"0.35\"));\n }\n return _done(w);\n }\n\n /// A pebble for every partner (12 at most), left, top and right of the stone, each tied to it by a thread.\n function _pebbles(Ctx memory c, Mat memory m, uint256 partners) private pure returns (bytes memory, bytes memory) {\n uint256 shown = partners < 12 ? partners : 12;\n Buf memory t = _new(900);\n Buf memory p = _new(24000);\n for (uint256 i = 0; i < shown; i++) {\n int256 a = 148 + int256((2 * i + 1) * 245 / (2 * shown));\n int256 px = 5000 + _cos(c, a) * 3920 / 10000;\n int256 py = 4800 + _sin(c, a) * 3920 / 10000;\n int256[] memory vx = new int256[](8);\n int256[] memory vy = new int256[](8);\n for (uint256 k = 0; k < 8; k++) {\n int256 rr = 270 + _rnd(c, 71);\n vx[k] = px + _cos(c, int256(45 * k)) * rr / 10000;\n vy[k] = py + _sin(c, int256(45 * k)) * rr * 9 / 100000;\n }\n _s(t, '