StonkScan — Robinhood Chain explorer

loading address

querying index

src/launch-nft/StonkBrokers.solentry file

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/interfaces/IERC20.sol"; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/common/ERC2981.sol"; import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import "@openzeppelin/contracts/utils/Base64.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@limitbreak/creator-token-standards/src/interfaces/ICreatorToken.sol"; import "@limitbreak/creator-token-standards/src/interfaces/ICreatorTokenLegacy.sol" as Legacy; import "@limitbreak/creator-token-standards/src/interfaces/ITransferValidator.sol"; import "./ERC6551Registry.sol"; import "./StonkBrokerSvgRendererV6Proposal.sol"; import "./libraries/StonkBrokerTraitsV6Proposal.sol"; /// @notice Minimal interface for the separately-deployed pre-reveal placeholder contract (see /// StonkBrokerPlaceholderV6) — kept as an interface here rather than importing the full contract /// so StonkBrokers doesn't need to know anything about it beyond this one function. interface IStonkBrokerPlaceholder { function placeholderSvg(uint256 tokenId) external pure returns (string memory); } /// @notice Minimal interface for the Anvil-market ActivationManager (see /// stonkbrokers/anvil-nftfi). Activation must reset on every true ownership transfer — with no /// custody exceptions — so the transfer hook below notifies the manager on each one. interface IActivationClearer { function clearActivation(uint256 tokenId) external; } /// @notice V6 mint contract — V4 art with Gold Tooth (face accessory #7). ERC-721C + EIP-2981. contract StonkBrokers is ERC721, ERC2981, Ownable, ReentrancyGuard, ICreatorToken { using Strings for uint256; uint256 public constant MAX_SUPPLY = 4444; /// @notice Whitelist mint is free — allocations are earned by burning Pup Cup / Clutch /// Puppies NFTs, not purchased. Kept as a named constant (rather than hardcoding 0 /// throughout) so the value-check logic below reads the same regardless of price. uint256 public constant MINT_PRICE = 0; uint256 public constant MAX_PER_TX = 10; uint96 public constant DEFAULT_ROYALTY_BPS = 666; // 6.66% uint8 public constant STAGE_COUNT = 3; /// @notice Number of blocks between arming the reveal (`commitReveal`) and the earliest block /// whose hash can be consumed by `reveal()`. The committing party cannot know this future /// blockhash at commit time, which is what makes the resulting shuffle unmanipulable — see /// the reveal section below for the full rationale. uint256 public constant REVEAL_DELAY = 5; error StonkBrokers__InvalidTransferValidatorContract(); error StonkBrokers__TransfersDisabled(); error StonkBrokers__InvalidStage(); error StonkBrokers__AlreadyRevealed(); error StonkBrokers__RevealNotArmed(); error StonkBrokers__RevealTooEarly(); error StonkBrokers__RevealCommitExpired(); error StonkBrokers__NothingMinted(); /// @notice ERC-721C transfer validator. Defaults to `address(0)` (no validator policy — /// every operator/marketplace is effectively whitelisted) until the owner explicitly opts /// into one via `setTransferValidator`. AUDIT NOTE: earlier drafts of this contract fell /// back to Limit Break's real, constant mainnet validator address /// (0x721C008f...) whenever no validator had been set. That address has no deployed code /// on Robinhood Chain, so any transfer attempted before an explicit `setTransferValidator` /// call would revert unexpectedly (a decode failure on the empty returndata) the moment /// `transfersEnabled` was flipped on — a self-inflicted denial of service, and the exact /// opposite of "transfer validator = 0 so everyone is whitelisted at launch." Defaulting /// to `address(0)` here removes that footgun entirely: unset == unrestricted, matching the /// global `transfersEnabled` lock as the sole gate until the owner deliberately layers on /// stricter ERC-721C policy (e.g. via `StonkBrokerTransferValidator`) later. address private transferValidator; /// @notice Hard global lock — while false, ERC721 transfers (mint/burn excluded) and /// approvals are blocked outright, regardless of the ERC-721C transfer validator policy. /// This is a stronger guarantee than the validator's operator whitelist: it also blocks /// direct wallet-to-wallet transfers and stops anyone from pre-arming an approval for a /// marketplace conduit (e.g. OpenSea Seaport) that would otherwise fire the instant this /// flips on. Off-chain listings can still be *created* (marketplaces don't touch our /// contract for that), but no listing can settle — the underlying transfer always reverts /// while locked, and no approval can exist to allow one to be readied in advance. bool public transfersEnabled; /// @notice Per-stage manual on/off switch, set by the owner. No timers — stages are /// opened and closed by explicit owner action only. mapping(uint8 => bool) public stageActive; /// @notice wallet => cumulative allocation ever granted, across all stages. Allocation is /// a single shared pool rather than per-stage buckets: unused allocation from an earlier /// stage automatically carries into later stages (it is never reset or re-granted), and /// `setWhitelist` can be called repeatedly over time (e.g. as more wallets earn slots via /// burns) without clobbering amounts already earned or already minted. mapping(address => uint256) public allocation; /// @notice wallet => cumulative amount minted so far, across all stages. mapping(address => uint256) public minted; ERC6551Registry public immutable registry; address public immutable accountImplementation; StonkBrokerSvgRendererV6Proposal public immutable renderer; bytes32 public constant ACCOUNT_SALT = bytes32(0); /// @notice Optional separately-deployed contract supplying the pre-reveal placeholder SVG /// (see StonkBrokerPlaceholderV6). Settable rather than constructor-immutable specifically so /// it can be deployed and wired up without changing this contract's constructor signature — /// the main renderer's bytecode is already close to the EIP-3860 initcode ceiling, so this /// placeholder logic intentionally lives in its own small deployment. Falls back to a minimal /// inline "?" placeholder if left unset (address(0)), so tokenURI() never breaks either way. address public placeholderRenderer; event PlaceholderRendererUpdated(address indexed oldRenderer, address indexed newRenderer); function setPlaceholderRenderer(address placeholderRenderer_) external onlyOwner { emit PlaceholderRendererUpdated(placeholderRenderer, placeholderRenderer_); placeholderRenderer = placeholderRenderer_; } /// @notice ActivationManager of the StonkBrokers Anvil market. When set, every true /// ownership transfer clears the token's paid activation tier (stock already in the /// token-bound wallet stays with the NFT). address(0) = feature off. address public activationManager; event ActivationManagerUpdated(address indexed oldManager, address indexed newManager); function setActivationManager(address activationManager_) external onlyOwner { emit ActivationManagerUpdated(activationManager, activationManager_); activationManager = activationManager_; } uint256 private nextTokenId = 1; uint256 private mintedCount; address[] private stockTokens; mapping(uint256 => address) public tokenWallet; mapping(uint256 => address) public fundedToken; mapping(uint256 => uint256) public initialWalletGrant; mapping(address => uint256) public fundedTokenMintCount; mapping(uint256 => uint256) public tokenTraitSeed; mapping(bytes32 => bool) private usedTraitSignatures; /// @notice DELAYED REVEAL (anti trait-sniping). /// /// Trait seeds are still assigned per-token at mint time exactly as before — the mint-time /// dedup loop is untouched, so uniqueness and the "contract can never block itself" guarantee /// both hold. What changes is WHICH stored seed each `tokenId` actually *displays*: until the /// collection is revealed, every token shows placeholder metadata/art, and at reveal a single /// collection-wide rotation offset (`startingIndex`) permutes the mapping of tokenId -> stored /// seed. Because the whole assignment is a rotation of the already-dedup'd seed set, the /// revealed collection is still perfectly unique. /// /// WHY THIS DEFEATS SNIPING: the pre-reveal problem is that `candidateSeed`/`decode` are pure /// functions of `tokenId`, so anyone could compute the entire rarity map in advance and mint /// into a known-rare `tokenId` (proven exploitable on testnet). After this change, the traits /// a `tokenId` ends up with depend on `startingIndex`, which is derived from the hash of a /// block that does not exist yet when the reveal is armed. No minter — and no one else — can /// know or influence it while minting is open, so there is no `tokenId` to target. /// /// WHY IT'S UNMANIPULABLE EVEN BY THE OWNER: `reveal()` consumes `blockhash(revealCommitBlock)` /// where `revealCommitBlock` was fixed `REVEAL_DELAY` blocks in the future by an earlier /// `commitReveal()` call. The owner commits before that block is mined, so they cannot grind /// the outcome; and `reveal()` itself is permissionless, so the owner also cannot withhold it. bool public revealed; /// @notice Block whose hash will seed the shuffle; 0 until `commitReveal` arms it. uint256 public revealCommitBlock; /// @notice Rotation offset applied to the tokenId -> stored-seed mapping; set at reveal. uint256 public startingIndex; /// @notice Supply frozen at reveal time; the rotation is taken modulo this value. uint256 public revealSupply; event WalletCreated(uint256 indexed tokenId, address indexed wallet); event WalletFunded(uint256 indexed tokenId, address indexed stockToken, uint256 amount); event StageStatusUpdated(uint8 indexed stage, bool active); /// @param stage which stage batch this addition was made under (for bookkeeping only — /// the granted amount is added to the wallet's single shared allocation pool). /// @param amountAdded the incremental allocation granted by this call. /// @param newTotalAllocation the wallet's cumulative allocation after this addition. event WhitelistAllocationAdded(uint8 indexed stage, address indexed wallet, uint256 amountAdded, uint256 newTotalAllocation); event TransfersEnabledUpdated(bool enabled); /// @param commitBlock the future block whose hash `reveal()` will consume (>= this + 1). event RevealArmed(uint256 commitBlock); event Revealed(uint256 startingIndex, uint256 supply); /// @notice ERC-4906 metadata-refresh signal. Explorers (Blockscout) and marketplaces /// (OpenSea, etc.) cache each token's metadata the first time they index it — which for /// this collection is the PRE-reveal placeholder. Without this event, `reveal()` flips /// `tokenURI` on-chain but every indexer keeps showing the cached placeholder until /// someone manually requests a per-token refresh (exactly the "explorer doesn't show /// these NFTs as revealed" failure observed on testnet). Emitting the standard /// BatchMetadataUpdate over the full ID range at reveal time tells all of them to /// re-fetch automatically. event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId); constructor( address[] memory stockTokenAddresses, address registryAddress, address accountImplementationAddress, address rendererAddress, address initialOwner, address royaltyReceiver ) ERC721("StonkBrokers", "STONK") Ownable(initialOwner) { require(stockTokenAddresses.length > 0, "no stock tokens"); require(registryAddress != address(0), "registry=0"); require(accountImplementationAddress != address(0), "account impl=0"); require(rendererAddress != address(0), "renderer=0"); registry = ERC6551Registry(registryAddress); accountImplementation = accountImplementationAddress; renderer = StonkBrokerSvgRendererV6Proposal(rendererAddress); for (uint256 i = 0; i < stockTokenAddresses.length; i++) { require(stockTokenAddresses[i] != address(0), "stock token=0"); stockTokens.push(stockTokenAddresses[i]); } _setDefaultRoyalty(royaltyReceiver, DEFAULT_ROYALTY_BPS); // transferValidator starts at address(0) (Solidity's default) — no event needed since // nothing changes from that default; see the field's doc comment above. } /// @notice Mint using your whitelist allocation while the given stage is open. Every mint /// on this collection is gated by an explicit per-wallet allocation set by the owner via /// `setWhitelist` — there is no open/public mint path. `stage` only selects which mint /// window must currently be active; the allocation itself is a single pool shared across /// all stages (unused allocation from an earlier stage remains spendable in a later one). function mint(uint8 stage, uint256 quantity) external payable nonReentrant { // Once revealed, the tokenId -> traits mapping is public knowledge, so any further mint // would be trivially snipeable. Minting must be fully complete before reveal. if (revealed) revert StonkBrokers__AlreadyRevealed(); if (stage >= STAGE_COUNT) revert StonkBrokers__InvalidStage(); require(stageActive[stage], "stage not active"); require(quantity > 0, "qty=0"); require(quantity <= MAX_PER_TX, "qty too high"); require(mintedCount + quantity <= MAX_SUPPLY, "sold out"); require(msg.value == MINT_PRICE * quantity, "wrong value"); uint256 alreadyMinted = minted[msg.sender]; require(alreadyMinted + quantity <= allocation[msg.sender], "exceeds allocation"); minted[msg.sender] = alreadyMinted + quantity; for (uint256 i = 0; i < quantity; i++) { uint256 tokenId = nextTokenId; nextTokenId += 1; mintedCount += 1; _assignUniqueTraitSeed(tokenId); _safeMint(msg.sender, tokenId); address wallet = registry.createAccount( accountImplementation, ACCOUNT_SALT, block.chainid, address(this), tokenId ); tokenWallet[tokenId] = wallet; emit WalletCreated(tokenId, wallet); (address tokenAddress, uint256 tokenBalance) = _pickFundableStockToken(tokenId); uint256 grant = _stockGrantForToken(tokenId, tokenAddress, tokenBalance); require(grant > 0, "grant=0"); fundedToken[tokenId] = tokenAddress; initialWalletGrant[tokenId] = grant; require(IERC20(tokenAddress).transfer(wallet, grant), "token transfer failed"); fundedTokenMintCount[tokenAddress] += 1; emit WalletFunded(tokenId, tokenAddress, grant); } } function withdrawMintProceeds(address payable to) external onlyOwner { require(to != address(0), "to=0"); (bool ok, ) = to.call{value: address(this).balance}(""); require(ok, "withdraw failed"); } /// @notice Turn a whitelist stage on or off. Manual only — no timers or auto-expiry. function setStageActive(uint8 stage, bool active) external onlyOwner { if (stage >= STAGE_COUNT) revert StonkBrokers__InvalidStage(); stageActive[stage] = active; emit StageStatusUpdated(stage, active); } /// @notice Batch-grant additional whitelist allocation, tagged under `stage` for /// bookkeeping. Amounts are ADDITIVE — calling this again for a wallet (e.g. because more /// wallets earned slots via burns after the first snapshot) tops up its allocation rather /// than overwriting it, so previously-granted or already-minted amounts are never lost. /// Emits one event per wallet so the frontend/an indexer can reconstruct the full /// whitelist history without needing an on-chain enumerable array. function setWhitelist(uint8 stage, address[] calldata wallets, uint256[] calldata allocations) external onlyOwner { if (stage >= STAGE_COUNT) revert StonkBrokers__InvalidStage(); require(wallets.length == allocations.length, "length mismatch"); for (uint256 i = 0; i < wallets.length; i++) { uint256 newTotal = allocation[wallets[i]] + allocations[i]; allocation[wallets[i]] = newTotal; emit WhitelistAllocationAdded(stage, wallets[i], allocations[i], newTotal); } } /// @notice Global switch for secondary transfers. Defaults to false at deploy — no /// transfer of any kind (including direct wallet-to-wallet) succeeds until the owner /// calls this with `true`. Independent of, and stronger than, the ERC-721C validator. function setTransfersEnabled(bool enabled) external onlyOwner { transfersEnabled = enabled; emit TransfersEnabledUpdated(enabled); } /// @notice Step 1 of 2 — arm the reveal. Records a block `REVEAL_DELAY` in the future whose /// (not-yet-known) hash `reveal()` will later consume as the shuffle seed. Call this once the /// mint is finished. Safe to call again to re-arm (e.g. if `reveal()` was left unfinalized /// long enough that the committed blockhash aged out of the EVM's 256-block window). Owner- /// only so only the team decides *when* the reveal window opens; the actual randomness comes /// from the future blockhash, which the owner cannot know or choose at this point. function commitReveal() external onlyOwner { if (revealed) revert StonkBrokers__AlreadyRevealed(); if (mintedCount == 0) revert StonkBrokers__NothingMinted(); revealCommitBlock = block.number + REVEAL_DELAY; emit RevealArmed(revealCommitBlock); } /// @notice Step 2 of 2 — finalize the reveal. Permissionless on purpose: once armed, anyone /// can trigger it (the frontend does so automatically after the delay), so the owner can /// neither stall the reveal nor cherry-pick the block it lands in. Derives the collection-wide /// rotation `startingIndex` from `blockhash(revealCommitBlock)`. If that block has aged past /// the EVM's 256-block hash window (`blockhash` returns 0), it reverts and the owner must /// re-arm via `commitReveal()` — the shuffle is never seeded from a zero hash. function reveal() external { if (revealed) revert StonkBrokers__AlreadyRevealed(); if (revealCommitBlock == 0) revert StonkBrokers__RevealNotArmed(); if (block.number <= revealCommitBlock) revert StonkBrokers__RevealTooEarly(); bytes32 bh = blockhash(revealCommitBlock); if (bh == bytes32(0)) revert StonkBrokers__RevealCommitExpired(); uint256 n = mintedCount; uint256 idx = uint256(keccak256(abi.encodePacked(bh, address(this), n))) % n; // Avoid the degenerate identity rotation (0), which would leave the as-minted order — // i.e. the fully predictable mapping — in place. Any other value is an equally-random // rotation of the unique seed set. if (idx == 0) idx = 1; startingIndex = idx; revealSupply = n; revealed = true; emit Revealed(idx, n); // ERC-4906: every token's metadata just changed (placeholder -> real art), so tell // indexers to re-fetch the whole range in one event. emit BatchMetadataUpdate(1, n); } /// @dev The stored seed that `tokenId` actually renders with, after applying the reveal /// rotation. Reverts if called before reveal (callers gate on `revealed` and show a /// placeholder instead). Because this is a pure rotation over positions `1..revealSupply`, /// it is a bijection: the revealed collection displays exactly the same unique set of seeds /// that mint-time dedup produced, just remapped to different tokenIds. function _effectiveSeed(uint256 tokenId) internal view returns (uint256) { uint256 n = revealSupply; uint256 position = ((tokenId - 1 + startingIndex) % n) + 1; return tokenTraitSeed[position]; } /// @notice Convenience view for the frontend: how many more this wallet can still mint, /// total, right now (shared across whichever stage(s) happen to be active). function remainingAllocation(address wallet) external view returns (uint256) { uint256 total = allocation[wallet]; uint256 used = minted[wallet]; return total > used ? total - used : 0; } function totalSupply() external view returns (uint256) { return mintedCount; } /// @notice The revealed trait seed for `tokenId`. Returns 0 before reveal — the mapping is /// intentionally hidden until then so nobody can front-run the shuffle (the raw stored seeds /// remain readable via `tokenTraitSeed`, but without `startingIndex` they can't be tied to a /// tokenId, so exposing nothing here keeps the reveal airtight). function traitSeedOf(uint256 tokenId) external view returns (uint256) { _requireOwned(tokenId); if (!revealed) return 0; return _effectiveSeed(tokenId); } /// @notice The revealed trait signature for `tokenId`; `bytes32(0)` before reveal. Used by /// the dedupe audit — post-reveal every token's signature is still unique (rotation is a /// bijection over the dedup'd seed set). function traitSignatureOf(uint256 tokenId) external view returns (bytes32) { _requireOwned(tokenId); if (!revealed) return bytes32(0); return renderer.traitSignatureFromSeed(_effectiveSeed(tokenId)); } function previewSvg(uint256 tokenId, uint256 traitSeed) external view returns (string memory) { return renderer.renderSvg(tokenId, traitSeed); } function tokenURI(uint256 tokenId) public view override returns (string memory) { _requireOwned(tokenId); // Pre-reveal: every token shows the same placeholder so traits can't be read (or // inferred) before the collection-wide shuffle is locked in. Only the wallet address is // shown since it is assigned at mint and isn't part of the shuffled art. if (!revealed) { return _placeholderTokenURI(tokenId); } uint256 seed = _effectiveSeed(tokenId); string memory image = renderer.renderSvg(tokenId, seed); address wallet = tokenWallet[tokenId]; // Wallet balances are deliberately NOT surfaced as traits: broker wallets accumulate // multiple stock tokens over time (StockBooster airdrops AAPL/AMZN/NVDA and more), so // any single "stock" attribute would misrepresent the portfolio. The wallet address is // the only account attribute — holders inspect balances directly. string memory visualAttrs = renderer.buildVisualAttributes(tokenId, seed); string memory json = string( abi.encodePacked( '{"name":"Stonk Broker #', tokenId.toString(), '","description":"4444 pixel stock-broker NFTs with dedicated onchain wallets funded at mint. ERC-721C with enforceable royalties.","attributes":[', visualAttrs, ',{"trait_type":"Wallet Address","value":"', Strings.toHexString(uint256(uint160(wallet)), 20), '"}],"image":"data:image/svg+xml;base64,', Base64.encode(bytes(image)), '"}' ) ); return string(abi.encodePacked("data:application/json;base64,", Base64.encode(bytes(json)))); } /// @dev Placeholder metadata served for every token until `reveal()` runs. Deliberately /// carries NO visual trait attributes so nothing about the shuffled art can be inferred early. function _placeholderTokenURI(uint256 tokenId) internal view returns (string memory) { address wallet = tokenWallet[tokenId]; string memory image = placeholderRenderer == address(0) ? '<svg xmlns="http://www.w3.org/2000/svg" width="480" height="480" viewBox="0 0 480 480">' '<rect width="480" height="480" fill="#0a0c10"/>' '<rect x="150" y="120" width="180" height="180" rx="14" fill="#151a24" stroke="#2a3142" stroke-width="4"/>' '<text x="240" y="235" font-family="monospace" font-size="120" fill="#f5d36b" text-anchor="middle">?</text>' '<text x="240" y="360" font-family="monospace" font-size="30" fill="#e8ecf4" text-anchor="middle">STONK BROKER</text>' '<text x="240" y="398" font-family="monospace" font-size="22" fill="#8b95a8" text-anchor="middle">UNREVEALED</text>' "</svg>" : IStonkBrokerPlaceholder(placeholderRenderer).placeholderSvg(tokenId); string memory json = string( abi.encodePacked( '{"name":"Stonk Broker #', tokenId.toString(), ' (Unrevealed)","description":"4444 pixel stock-broker NFTs with dedicated onchain wallets funded at mint. Traits are hidden until the collection-wide reveal to prevent trait sniping.","attributes":[', '{"trait_type":"Status","value":"Unrevealed"}', ',{"trait_type":"Wallet Address","value":"', Strings.toHexString(uint256(uint160(wallet)), 20), '"}],"image":"data:image/svg+xml;base64,', Base64.encode(bytes(image)), '"}' ) ); return string(abi.encodePacked("data:application/json;base64,", Base64.encode(bytes(json)))); } function predictWallet(uint256 tokenId) external view returns (address) { return registry.account(accountImplementation, ACCOUNT_SALT, block.chainid, address(this), tokenId); } function stockTokenCount() external view returns (uint256) { return stockTokens.length; } function stockTokenAt(uint256 index) external view returns (address) { require(index < stockTokens.length, "index out of bounds"); return stockTokens[index]; } function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner { _setDefaultRoyalty(receiver, feeNumerator); } function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) external onlyOwner { _setTokenRoyalty(tokenId, receiver, feeNumerator); } function setTransferValidator(address transferValidator_) public onlyOwner { bool isValidTransferValidator = transferValidator_.code.length > 0; if (transferValidator_ != address(0) && !isValidTransferValidator) { revert StonkBrokers__InvalidTransferValidatorContract(); } emit TransferValidatorUpdated(transferValidator, transferValidator_); transferValidator = transferValidator_; } /// @notice `address(0)` until the owner explicitly sets one — see the field's doc comment. function getTransferValidator() public view returns (address validator) { return transferValidator; } function getTransferValidationFunction() external pure returns (bytes4 functionSignature, bool isViewFunction) { functionSignature = bytes4(keccak256("validateTransfer(address,address,address,uint256)")); isViewFunction = true; } function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC2981) returns (bool) { return interfaceId == type(ICreatorToken).interfaceId || interfaceId == type(Legacy.ICreatorTokenLegacy).interfaceId || // ERC-4906 (metadata update events). The spec fixes this ID at 0x49064906 rather // than deriving it from a function-selector XOR, because the standard defines only // events. Advertising it is how OpenSea/Blockscout know to listen for the // BatchMetadataUpdate we emit in reveal(). interfaceId == bytes4(0x49064906) || super.supportsInterface(interfaceId); } /// @notice Blocks approvals while the global transfer lock is on, so no marketplace /// conduit (e.g. OpenSea's Seaport) can be pre-approved to fire the instant transfers /// are enabled. Approvals work normally once `transfersEnabled` is true. function approve(address to, uint256 tokenId) public virtual override { if (!transfersEnabled) revert StonkBrokers__TransfersDisabled(); super.approve(to, tokenId); } /// @notice Same rationale as `approve` — blocked while the global transfer lock is on. function setApprovalForAll(address operator, bool approved) public virtual override { if (!transfersEnabled) revert StonkBrokers__TransfersDisabled(); super.setApprovalForAll(operator, approved); } function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) { address from = _ownerOf(tokenId); if (from != address(0) && to != address(0)) { if (!transfersEnabled) revert StonkBrokers__TransfersDisabled(); address validator = getTransferValidator(); if (validator != address(0) && msg.sender != validator) { ITransferValidator(validator).validateTransfer(_msgSender(), from, to, tokenId); } // Clear the Anvil-market activation tier on every true ownership change (mints are // excluded — from == 0 — and burns don't exist here). try/catch because a transfer // hook must never be able to brick transfers, even if the manager misbehaves. // AUDIT NOTE (gas-griefing): deliberately starving this subcall so the clear OOGs // while the transfer completes is infeasible — under EIP-150 the subcall receives // 63/64 of available gas, so for the remaining 1/64 to still cover the transfer's // own storage writes (~30k), the subcall would have to receive ~1.9M gas, orders of // magnitude more than clearActivation's ~50k worst case. It cannot OOG first. address manager = activationManager; if (manager != address(0)) { try IActivationClearer(manager).clearActivation(tokenId) {} catch {} } } return super._update(to, tokenId, auth); } function _assignUniqueTraitSeed(uint256 tokenId) internal { for (uint256 attempt = 0; attempt < 256; attempt++) { uint256 seed = StonkBrokerTraitsV6Proposal.candidateSeed(tokenId, attempt); bytes32 sig = renderer.traitSignatureFromSeed(seed); if (!usedTraitSignatures[sig]) { usedTraitSignatures[sig] = true; tokenTraitSeed[tokenId] = seed; return; } } revert("trait space exhausted"); } function _stockGrantForToken(uint256 tokenId, address tokenAddress, uint256 tokenBalance) internal view returns (uint256) { uint256 remainingMints = (MAX_SUPPLY - tokenId) + 1; uint256 expectedMintsForToken = (remainingMints / stockTokens.length) + 1; uint256 perMintBudget = tokenBalance / expectedMintsForToken; if (perMintBudget == 0) { return tokenBalance > 0 ? 1 : 0; } uint256 seed = uint256(keccak256(abi.encodePacked("STONK_BROKERS_V6", tokenId, tokenAddress))); uint256 grantBps = 6500 + (seed % 3501); uint256 grant = (perMintBudget * grantBps) / 10_000; if (grant == 0) return 1; if (grant > tokenBalance) return tokenBalance; return grant; } function _pickFundableStockToken(uint256 tokenId) internal view returns (address tokenAddress, uint256 tokenBalance) { uint256 minAssigned = type(uint256).max; uint256 eligibleCount = 0; for (uint256 i = 0; i < stockTokens.length; i++) { address candidate = stockTokens[i]; uint256 balance = IERC20(candidate).balanceOf(address(this)); if (balance == 0) continue; if (_stockGrantForToken(tokenId, candidate, balance) == 0) continue; uint256 assigned = fundedTokenMintCount[candidate]; if (assigned < minAssigned) { minAssigned = assigned; eligibleCount = 1; } else if (assigned == minAssigned) { eligibleCount += 1; } } if (eligibleCount == 0) { revert("insufficient token inventory"); } uint256 pick = uint256(keccak256(abi.encodePacked("STONK_STOCK_PICK_V6", tokenId, mintedCount))) % eligibleCount; uint256 cursor = 0; for (uint256 i = 0; i < stockTokens.length; i++) { address candidate = stockTokens[i]; uint256 balance = IERC20(candidate).balanceOf(address(this)); if (balance > 0 && _stockGrantForToken(tokenId, candidate, balance) > 0 && fundedTokenMintCount[candidate] == minAssigned) { if (cursor == pick) return (candidate, balance); cursor += 1; } } revert("insufficient token inventory"); } }

imports33 files

src/launch-nft/vendor/interfaces/ICreatorToken.sol

// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; // Vendored verbatim from limitbreakinc/creator-token-standards (src/interfaces/ICreatorToken.sol) // because this machine has no node_modules; the interfaceId MUST match the canonical package. interface ICreatorToken { event TransferValidatorUpdated(address oldValidator, address newValidator); function getTransferValidator() external view returns (address validator); function setTransferValidator(address validator) external; function getTransferValidationFunction() external view returns (bytes4 functionSignature, bool isViewFunction); }

lib/openzeppelin-contracts/contracts/utils/math/Math.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol) pragma solidity ^0.8.20; import {Panic} from "../Panic.sol"; import {SafeCast} from "./SafeCast.sol"; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Return the 512-bit addition of two uint256. * * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low. */ function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) { assembly ("memory-safe") { low := add(a, b) high := lt(low, a) } } /** * @dev Return the 512-bit multiplication of two uint256. * * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low. */ function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) { // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = high * 2²⁵⁶ + low. assembly ("memory-safe") { let mm := mulmod(a, b, not(0)) low := mul(a, b) high := sub(sub(mm, low), lt(mm, low)) } } /** * @dev Returns the addition of two unsigned integers, with a success flag (no overflow). */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a + b; success = c >= a; result = c * SafeCast.toUint(success); } } /** * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow). */ function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a - b; success = c <= a; result = c * SafeCast.toUint(success); } } /** * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow). */ function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a * b; assembly ("memory-safe") { // Only true when the multiplication doesn't overflow // (c / a == b) || (a == 0) success := or(eq(div(c, a), b), iszero(a)) } // equivalent to: success ? c : 0 result = c * SafeCast.toUint(success); } } /** * @dev Returns the division of two unsigned integers, with a success flag (no division by zero). */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { success = b > 0; assembly ("memory-safe") { // The `DIV` opcode returns zero when the denominator is 0. result := div(a, b) } } } /** * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero). */ function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { success = b > 0; assembly ("memory-safe") { // The `MOD` opcode returns zero when the denominator is 0. result := mod(a, b) } } } /** * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing. */ function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) { (bool success, uint256 result) = tryAdd(a, b); return ternary(success, result, type(uint256).max); } /** * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing. */ function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) { (, uint256 result) = trySub(a, b); return result; } /** * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing. */ function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) { (bool success, uint256 result) = tryMul(a, b); return ternary(success, result, type(uint256).max); } /** * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant. * * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone. * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute * one branch when needed, making this function more expensive. */ function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) { unchecked { // branchless ternary works because: // b ^ (a ^ b) == a // b ^ 0 == b return b ^ ((a ^ b) * SafeCast.toUint(condition)); } } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return ternary(a > b, a, b); } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return ternary(a < b, a, b); } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { unchecked { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. Panic.panic(Panic.DIVISION_BY_ZERO); } // The following calculation ensures accurate ceiling division without overflow. // Since a is non-zero, (a - 1) / b will not overflow. // The largest possible result occurs when (a - 1) / b is type(uint256).max, // but the largest value we can obtain is type(uint256).max - 1, which happens // when a = type(uint256).max and b = 1. unchecked { return SafeCast.toUint(a > 0) * ((a - 1) / b + 1); } } /** * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { (uint256 high, uint256 low) = mul512(x, y); // Handle non-overflow cases, 256 by 256 division. if (high == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return low / denominator; } // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0. if (denominator <= high) { Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW)); } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [high low]. uint256 remainder; assembly ("memory-safe") { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. high := sub(high, gt(remainder, low)) low := sub(low, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); assembly ("memory-safe") { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [high low] by twos. low := div(low, twos) // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from high into low. low |= high * twos; // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv ≡ 1 mod 2⁴. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also // works in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2⁸ inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶ inverse *= 2 - denominator * inverse; // inverse mod 2³² inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴ inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸ inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶ // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high // is no longer required. result = low * inverse; return result; } } /** * @dev Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0); } /** * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256. */ function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) { unchecked { (uint256 high, uint256 low) = mul512(x, y); if (high >= 1 << n) { Panic.panic(Panic.UNDER_OVERFLOW); } return (high << (256 - n)) | (low >> n); } } /** * @dev Calculates x * y >> n with full precision, following the selected rounding direction. */ function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) { return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0); } /** * @dev Calculate the modular multiplicative inverse of a number in Z/nZ. * * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0. * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible. * * If the input value is not inversible, 0 is returned. * * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}. */ function invMod(uint256 a, uint256 n) internal pure returns (uint256) { unchecked { if (n == 0) return 0; // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version) // Used to compute integers x and y such that: ax + ny = gcd(a, n). // When the gcd is 1, then the inverse of a modulo n exists and it's x. // ax + ny = 1 // ax = 1 + (-y)n // ax ≡ 1 (mod n) # x is the inverse of a modulo n // If the remainder is 0 the gcd is n right away. uint256 remainder = a % n; uint256 gcd = n; // Therefore the initial coefficients are: // ax + ny = gcd(a, n) = n // 0a + 1n = n int256 x = 0; int256 y = 1; while (remainder != 0) { uint256 quotient = gcd / remainder; (gcd, remainder) = ( // The old remainder is the next gcd to try. remainder, // Compute the next remainder. // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd // where gcd is at most n (capped to type(uint256).max) gcd - remainder * quotient ); (x, y) = ( // Increment the coefficient of a. y, // Decrement the coefficient of n. // Can overflow, but the result is casted to uint256 so that the // next value of y is "wrapped around" to a value between 0 and n - 1. x - y * int256(quotient) ); } if (gcd != 1) return 0; // No inverse exists. return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative. } } /** * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`. * * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that * `a**(p-2)` is the modular multiplicative inverse of a in Fp. * * NOTE: this function does NOT check that `p` is a prime greater than `2`. */ function invModPrime(uint256 a, uint256 p) internal view returns (uint256) { unchecked { return Math.modExp(a, p - 2, p); } } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m) * * Requirements: * - modulus can't be zero * - underlying staticcall to precompile must succeed * * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make * sure the chain you're using it on supports the precompiled contract for modular exponentiation * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, * the underlying function will succeed given the lack of a revert, but the result may be incorrectly * interpreted as 0. */ function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) { (bool success, uint256 result) = tryModExp(b, e, m); if (!success) { Panic.panic(Panic.DIVISION_BY_ZERO); } return result; } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m). * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying * to operate modulo 0 or if the underlying precompile reverted. * * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack * of a revert, but the result may be incorrectly interpreted as 0. */ function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) { if (m == 0) return (false, 0); assembly ("memory-safe") { let ptr := mload(0x40) // | Offset | Content | Content (Hex) | // |-----------|------------|--------------------------------------------------------------------| // | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x60:0x7f | value of b | 0x<.............................................................b> | // | 0x80:0x9f | value of e | 0x<.............................................................e> | // | 0xa0:0xbf | value of m | 0x<.............................................................m> | mstore(ptr, 0x20) mstore(add(ptr, 0x20), 0x20) mstore(add(ptr, 0x40), 0x20) mstore(add(ptr, 0x60), b) mstore(add(ptr, 0x80), e) mstore(add(ptr, 0xa0), m) // Given the result < m, it's guaranteed to fit in 32 bytes, // so we can use the memory scratch space located at offset 0. success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20) result := mload(0x00) } } /** * @dev Variant of {modExp} that supports inputs of arbitrary length. */ function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) { (bool success, bytes memory result) = tryModExp(b, e, m); if (!success) { Panic.panic(Panic.DIVISION_BY_ZERO); } return result; } /** * @dev Variant of {tryModExp} that supports inputs of arbitrary length. */ function tryModExp( bytes memory b, bytes memory e, bytes memory m ) internal view returns (bool success, bytes memory result) { if (_zeroBytes(m)) return (false, new bytes(0)); uint256 mLen = m.length; // Encode call args in result and move the free memory pointer result = abi.encodePacked(b.length, e.length, mLen, b, e, m); assembly ("memory-safe") { let dataPtr := add(result, 0x20) // Write result on top of args to avoid allocating extra memory. success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen) // Overwrite the length. // result.length > returndatasize() is guaranteed because returndatasize() == m.length mstore(result, mLen) // Set the memory pointer after the returned data. mstore(0x40, add(dataPtr, mLen)) } } /** * @dev Returns whether the provided byte array is zero. */ function _zeroBytes(bytes memory buffer) private pure returns (bool) { uint256 chunk; for (uint256 i = 0; i < buffer.length; i += 0x20) { // See _unsafeReadBytesOffset from utils/Bytes.sol assembly ("memory-safe") { chunk := mload(add(add(buffer, 0x20), i)) } if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) { return false; } } return true; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * This method is based on Newton's method for computing square roots; the algorithm is restricted to only * using integer operations. */ function sqrt(uint256 a) internal pure returns (uint256) { unchecked { // Take care of easy edge cases when a == 0 or a == 1 if (a <= 1) { return a; } // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between // the current value as `ε_n = | x_n - sqrt(a) |`. // // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is // bigger than any uint256. // // By noticing that // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)` // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar // to the msb function. uint256 aa = a; uint256 xn = 1; if (aa >= (1 << 128)) { aa >>= 128; xn <<= 64; } if (aa >= (1 << 64)) { aa >>= 64; xn <<= 32; } if (aa >= (1 << 32)) { aa >>= 32; xn <<= 16; } if (aa >= (1 << 16)) { aa >>= 16; xn <<= 8; } if (aa >= (1 << 8)) { aa >>= 8; xn <<= 4; } if (aa >= (1 << 4)) { aa >>= 4; xn <<= 2; } if (aa >= (1 << 2)) { xn <<= 1; } // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1). // // We can refine our estimation by noticing that the middle of that interval minimizes the error. // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2). // This is going to be our x_0 (and ε_0) xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2) // From here, Newton's method give us: // x_{n+1} = (x_n + a / x_n) / 2 // // One should note that: // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a // = ((x_n² + a) / (2 * x_n))² - a // = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a // = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²) // = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²) // = (x_n² - a)² / (2 * x_n)² // = ((x_n² - a) / (2 * x_n))² // ≥ 0 // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n // // This gives us the proof of quadratic convergence of the sequence: // ε_{n+1} = | x_{n+1} - sqrt(a) | // = | (x_n + a / x_n) / 2 - sqrt(a) | // = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) | // = | (x_n - sqrt(a))² / (2 * x_n) | // = | ε_n² / (2 * x_n) | // = ε_n² / | (2 * x_n) | // // For the first iteration, we have a special case where x_0 is known: // ε_1 = ε_0² / | (2 * x_0) | // ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2))) // ≤ 2**(2*e-4) / (3 * 2**(e-1)) // ≤ 2**(e-3) / 3 // ≤ 2**(e-3-log2(3)) // ≤ 2**(e-4.5) // // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n: // ε_{n+1} = ε_n² / | (2 * x_n) | // ≤ (2**(e-k))² / (2 * 2**(e-1)) // ≤ 2**(2*e-2*k) / 2**e // ≤ 2**(e-2*k) xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5 xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9 xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18 xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36 xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72 // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either // sqrt(a) or sqrt(a) + 1. return xn - SafeCast.toUint(xn > a / xn); } } /** * @dev Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 x) internal pure returns (uint256 r) { // If value has upper 128 bits set, log2 result is at least 128 r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7; // If upper 64 bits of 128-bit half set, add 64 to result r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6; // If upper 32 bits of 64-bit half set, add 32 to result r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5; // If upper 16 bits of 32-bit half set, add 16 to result r |= SafeCast.toUint((x >> r) > 0xffff) << 4; // If upper 8 bits of 16-bit half set, add 8 to result r |= SafeCast.toUint((x >> r) > 0xff) << 3; // If upper 4 bits of 8-bit half set, add 4 to result r |= SafeCast.toUint((x >> r) > 0xf) << 2; // Shifts value right by the current result and use it as an index into this lookup table: // // | x (4 bits) | index | table[index] = MSB position | // |------------|---------|-----------------------------| // | 0000 | 0 | table[0] = 0 | // | 0001 | 1 | table[1] = 0 | // | 0010 | 2 | table[2] = 1 | // | 0011 | 3 | table[3] = 1 | // | 0100 | 4 | table[4] = 2 | // | 0101 | 5 | table[5] = 2 | // | 0110 | 6 | table[6] = 2 | // | 0111 | 7 | table[7] = 2 | // | 1000 | 8 | table[8] = 3 | // | 1001 | 9 | table[9] = 3 | // | 1010 | 10 | table[10] = 3 | // | 1011 | 11 | table[11] = 3 | // | 1100 | 12 | table[12] = 3 | // | 1101 | 13 | table[13] = 3 | // | 1110 | 14 | table[14] = 3 | // | 1111 | 15 | table[15] = 3 | // // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half). assembly ("memory-safe") { r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000)) } } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 x) internal pure returns (uint256 r) { // If value has upper 128 bits set, log2 result is at least 128 r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7; // If upper 64 bits of 128-bit half set, add 64 to result r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6; // If upper 32 bits of 64-bit half set, add 32 to result r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5; // If upper 16 bits of 32-bit half set, add 16 to result r |= SafeCast.toUint((x >> r) > 0xffff) << 4; // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8 return (r >> 3) | SafeCast.toUint((x >> r) > 0xff); } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } /** * @dev Counts the number of leading zero bits in a uint256. */ function clz(uint256 x) internal pure returns (uint256) { return ternary(x == 0, 256, 255 - log2(x)); } }

lib/openzeppelin-contracts/contracts/utils/Panic.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol) pragma solidity ^0.8.20; /** * @dev Helper library for emitting standardized panic codes. * * ```solidity * contract Example { * using Panic for uint256; * * // Use any of the declared internal constants * function foo() { Panic.GENERIC.panic(); } * * // Alternatively * function foo() { Panic.panic(Panic.GENERIC); } * } * ``` * * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil]. * * _Available since v5.1._ */ // slither-disable-next-line unused-state library Panic { /// @dev generic / unspecified error uint256 internal constant GENERIC = 0x00; /// @dev used by the assert() builtin uint256 internal constant ASSERT = 0x01; /// @dev arithmetic underflow or overflow uint256 internal constant UNDER_OVERFLOW = 0x11; /// @dev division or modulo by zero uint256 internal constant DIVISION_BY_ZERO = 0x12; /// @dev enum conversion error uint256 internal constant ENUM_CONVERSION_ERROR = 0x21; /// @dev invalid encoding in storage uint256 internal constant STORAGE_ENCODING_ERROR = 0x22; /// @dev empty array pop uint256 internal constant EMPTY_ARRAY_POP = 0x31; /// @dev array out of bounds access uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32; /// @dev resource error (too large allocation or too large array) uint256 internal constant RESOURCE_ERROR = 0x41; /// @dev calling invalid internal function uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51; /// @dev Reverts with a panic code. Recommended to use with /// the internal constants with predefined codes. function panic(uint256 code) internal pure { assembly ("memory-safe") { mstore(0x00, 0x4e487b71) mstore(0x20, code) revert(0x1c, 0x24) } } }

src/launch-nft/StonkBrokerSvgRendererV6Proposal.sol

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import "@openzeppelin/contracts/utils/Strings.sol"; import "./libraries/StonkBrokerTraitsV6Proposal.sol"; /// @notice Preview-only renderer for proposed V6 collection. /// V6 proposal art — Devil/Bull horns, Gold Tooth mouth (Smirk + 1px). contract StonkBrokerSvgRendererV6Proposal { using Strings for uint256; function traitSignatureFromSeed(uint256 seed) external pure returns (bytes32) { return StonkBrokerTraitsV6Proposal.traitSignature(seed); } function decodeTraits(uint256 seed) external pure returns (StonkBrokerTraitsV6Proposal.Traits memory) { return StonkBrokerTraitsV6Proposal.decode(seed); } function candidateTraitSeed(uint256 tokenId, uint256 attempt) external pure returns (uint256) { return StonkBrokerTraitsV6Proposal.candidateSeed(tokenId, attempt); } /// @notice Export individual art layers as standalone SVGs for off-chain QA review. function renderLayers(uint256 tokenId, uint256 traitSeed) external pure returns ( string memory background, string memory body, string memory skin, string memory hair, string memory eyes, string memory mouth, string memory faceAccessory, string memory brokerBadge, string memory composite ) { composite = renderSvg(tokenId, traitSeed); StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); string memory bgHex = _hex(_pickBackground(t.background)); string memory tieHex = _hex(_pickTie(t.tie)); string memory skinHex = _hex(_pickSkin(t.skin)); string memory hairHex = _hex(_pickHairColor(t.hairColor)); background = _wrapLayer( string(abi.encodePacked('<rect width="24" height="24" fill="#', bgHex, '"/>')), false ); body = _wrapLayer(_bodyForSuit(t.suit, tieHex, t.neckwear), true); skin = _wrapLayer(_svgSkinNeck(skinHex, t.skin, t.hairStyle), true); hair = _wrapLayer(_svgHair(t.hairStyle, hairHex), true); eyes = _wrapLayer(_eyeMarkup(t.eyeColor, _noseMarkup(t.noseColor)), true); mouth = _wrapLayer(_renderMouth(t.mouth), true); faceAccessory = _wrapLayer(_renderFaceAccessoryForHair(t.faceAccessory, t.hairStyle), true); brokerBadge = _wrapLayer(_renderBrokerBadge(t.brokerBadge), true); } function renderSvg(uint256 /* tokenId */, uint256 traitSeed) public pure returns (string memory) { StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); string memory bg = _hex(_pickBackground(t.background)); string memory tie = _hex(_pickTie(t.tie)); string memory skin = _hex(_pickSkin(t.skin)); string memory hair = _hex(_pickHairColor(t.hairColor)); return string( abi.encodePacked( _svgHead(bg), _svgFace(t, skin, hair, ""), _bodyForSuit(t.suit, tie, t.neckwear), _renderPocketSquare(t.pocketSquare), _renderFaceAccessoryForHair(t.faceAccessory, t.hairStyle), _renderBrokerBadge(t.brokerBadge), "</svg>" ) ); } /// @notice Attributes with a "None" value are omitted entirely rather than listed — /// tokens without that trait simply carry one fewer attribute (cleaner rarity tooling). function buildVisualAttributes(uint256 /* tokenId */, uint256 traitSeed) external pure returns (string memory) { StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); return string( abi.encodePacked( '{"trait_type":"Background","value":"', backgroundName(t.background), '"}', _attr("Skin", StonkBrokerTraitsV6Proposal.skinName(t.skin)), _attr("Hair Style", StonkBrokerTraitsV6Proposal.hairStyleName(t.hairStyle)), _attr("Hair Color", StonkBrokerTraitsV6Proposal.hairColorNameForMetadata(t.hairStyle, t.hairColor)), _attr("Eyes", StonkBrokerTraitsV6Proposal.eyeColorName(t.eyeColor)), _attr("Nose", StonkBrokerTraitsV6Proposal.noseColorName(t.noseColor)), _attr("Mouth", StonkBrokerTraitsV6Proposal.mouthName(t.mouth)), _attr("Suit", StonkBrokerTraitsV6Proposal.suitName(t.suit)), _attr("Tie", StonkBrokerTraitsV6Proposal.tieName(t.tie)), _attr("Neckwear", StonkBrokerTraitsV6Proposal.neckwearName(t.neckwear)), _attr("Face Accessory", StonkBrokerTraitsV6Proposal.faceAccessoryName(t.faceAccessory)), _attr("Broker Badge", StonkBrokerTraitsV6Proposal.brokerBadgeName(t.brokerBadge)), _attr("Pocket Square", StonkBrokerTraitsV6Proposal.pocketSquareName(t.pocketSquare)) ) ); } function _attr(string memory traitType, string memory value) internal pure returns (string memory) { if (keccak256(bytes(value)) == keccak256(bytes("None"))) return ""; return string(abi.encodePacked(',{"trait_type":"', traitType, '","value":"', value, '"}')); } function backgroundName(uint8 idx) internal pure returns (string memory) { if (idx == 0) return "Sky Blue"; if (idx == 1) return "Light Blue"; if (idx == 2) return "Pale Blue"; if (idx == 3) return "Tan"; if (idx == 4) return "Slate"; if (idx == 5) return "Steel"; if (idx == 6) return "Trading Floor Green"; return "Bloomberg Orange"; } function _svgHead(string memory bg) internal pure returns (string memory) { return string( abi.encodePacked( '<svg xmlns="http://www.w3.org/2000/svg" shape-rendering="crispEdges" viewBox="0 0 24 24" width="720" height="720"><rect width="24" height="24" fill="#', bg, '"/>' ) ); } function _svgBody(string memory suit, string memory tie, uint8 neckwear) internal pure returns (string memory) { return _svgBodyWithCollar(suit, tie, neckwear, "f0f0f0"); } function _svgBodyWithCollar( string memory suit, string memory tie, uint8 neckwear, string memory collar ) internal pure returns (string memory) { // Museum pass: bow wing flare · long-tie knot · collar V-notch string memory neck = neckwear == 1 ? string( abi.encodePacked( '<rect x="9" y="19" width="1" height="1" fill="#', tie, '"/><rect x="10" y="19" width="1" height="1" fill="#', tie, '"/><rect x="13" y="19" width="1" height="1" fill="#', tie, '"/><rect x="14" y="19" width="1" height="1" fill="#', tie, '"/><rect x="11" y="19" width="2" height="2" fill="#', tie, '"/>' ) ) : string( abi.encodePacked( '<rect x="10" y="19" width="4" height="1" fill="#', tie, '"/><rect x="11" y="20" width="2" height="4" fill="#', tie, '"/>' ) ); return string( abi.encodePacked( '<rect x="4" y="18" width="16" height="6" fill="#', suit, '"/><rect x="8" y="18" width="8" height="4" fill="#', suit, '"/>', '<rect x="10" y="18" width="1" height="2" fill="#', collar, '"/><rect x="13" y="18" width="1" height="2" fill="#', collar, '"/><rect x="11" y="18" width="2" height="1" fill="#', collar, '"/>', neck, '<rect x="3" y="19" width="1" height="5" fill="#', suit, '"/><rect x="20" y="19" width="1" height="5" fill="#', suit, '"/>' ) ); } /// @dev 6 Rainbow (~1%), 7 Pink (~0.5%), 8 Red solid (~1% rare). Idx 9 strips rejected / unused. function _bodyForSuit(uint8 suitIdx, string memory tie, uint8 neckwear) internal pure returns (string memory) { if (suitIdx == 6) return _svgBodyRainbow(tie, neckwear); if (suitIdx == 7) return _svgBodyWithCollar("ff4d94", tie, neckwear, "ffe0ec"); // 8 — solid crimson (same cut as commons); 9 unused return _svgBody(_hex(_pickSuit(suitIdx)), tie, neckwear); } function _svgBodyRainbow(string memory tie, uint8 neckwear) internal pure returns (string memory) { string memory neck = neckwear == 1 ? string( abi.encodePacked( '<rect x="9" y="19" width="1" height="1" fill="#', tie, '"/><rect x="10" y="19" width="1" height="1" fill="#', tie, '"/><rect x="13" y="19" width="1" height="1" fill="#', tie, '"/><rect x="14" y="19" width="1" height="1" fill="#', tie, '"/><rect x="11" y="19" width="2" height="2" fill="#', tie, '"/>' ) ) : string( abi.encodePacked( '<rect x="10" y="19" width="4" height="1" fill="#', tie, '"/><rect x="11" y="20" width="2" height="4" fill="#', tie, '"/>' ) ); return string( abi.encodePacked( '<rect x="4" y="18" width="2" height="6" fill="#e53935"/><rect x="6" y="18" width="2" height="6" fill="#fb8c00"/>', '<rect x="8" y="18" width="2" height="6" fill="#fdd835"/><rect x="10" y="18" width="2" height="6" fill="#43a047"/>', '<rect x="12" y="18" width="2" height="6" fill="#1e88e5"/><rect x="14" y="18" width="2" height="6" fill="#3949ab"/>', '<rect x="16" y="18" width="2" height="6" fill="#8e24aa"/><rect x="18" y="18" width="2" height="6" fill="#d81b60"/>', '<rect x="10" y="18" width="1" height="2" fill="#f0f0f0"/><rect x="13" y="18" width="1" height="2" fill="#f0f0f0"/>', '<rect x="11" y="18" width="2" height="1" fill="#f0f0f0"/>', neck, '<rect x="3" y="19" width="1" height="5" fill="#e53935"/><rect x="20" y="19" width="1" height="5" fill="#d81b60"/>' ) ); } function _svgFace( StonkBrokerTraitsV6Proposal.Traits memory t, string memory skin, string memory hair, string memory /* eye */ ) internal pure returns (string memory) { return string( abi.encodePacked( _svgSkinNeck(skin, t.skin, t.hairStyle), _svgHair(t.hairStyle, hair), _eyeMarkup(t.eyeColor, _noseMarkup(t.noseColor)), _renderMouth(t.mouth) ) ); } function _svgSkinNeck(string memory skin, uint8 skinType, uint8 hairStyle) internal pure returns (string memory) { string memory glow = ""; if (skinType == 10) { glow = '<rect x="6" y="3" width="12" height="14" fill="#59d37b" opacity="0.15"/>'; } else if (skinType == 11) { glow = '<rect x="7" y="4" width="10" height="12" fill="#ffe08a" opacity="0.25"/>'; } else if (skinType == 12) { glow = '<rect x="7" y="4" width="10" height="12" fill="#1a1a2e"/>'; } string memory ears = hairStyle == 6 ? string( abi.encodePacked( '<rect x="6" y="9" width="1" height="2" fill="#', skin, '"/><rect x="17" y="9" width="1" height="2" fill="#', skin, '"/>' ) ) : ""; return string( abi.encodePacked( glow, '<rect x="7" y="4" width="10" height="12" fill="#', skin, '"/><rect x="9" y="16" width="6" height="3" fill="#', skin, '"/>', ears ) ); } function _svgEyesNose(string memory eye, string memory noseMarkup) internal pure returns (string memory) { return string( abi.encodePacked( '<rect x="8" y="8" width="3" height="2" fill="#f4f4f4"/><rect x="13" y="8" width="3" height="2" fill="#f4f4f4"/>', '<rect x="9" y="8" width="1" height="1" fill="#', eye, '"/><rect x="14" y="8" width="1" height="1" fill="#', eye, '"/>', noseMarkup ) ); } /// @notice Eye markup keyed off the raw eyeColor idx (0–8) rather than a pre-resolved hex — /// needed because Bull Candle (8) swaps the pupil shape entirely rather than just its color, /// so it can't be expressed through `_pickEye`'s color table. Every render path that used to /// call `_svgEyesNose(_hex(_pickEye(idx)), ...)` now routes through here instead. function _eyeMarkup(uint8 eyeColorIdx, string memory noseMarkup) internal pure returns (string memory) { if (eyeColorIdx == 8) return _svgBullCandleEyes(noseMarkup); return _svgEyesNose(_hex(_pickEye(eyeColorIdx)), noseMarkup); } /// @notice Bull Candle eyes (~1% super rare) — each pupil becomes a tiny green candlestick /// (dark 1px wick over a green 1px body) in place of the flat color dot, within the exact /// same sclera footprint every other eye style uses (no extra canvas space needed). function _svgBullCandleEyes(string memory noseMarkup) internal pure returns (string memory) { return string( abi.encodePacked( '<rect x="8" y="8" width="3" height="2" fill="#f4f4f4"/><rect x="13" y="8" width="3" height="2" fill="#f4f4f4"/>', '<rect x="9" y="8" width="1" height="1" fill="#1a1a1a"/><rect x="9" y="9" width="1" height="1" fill="#2ee06a"/>', '<rect x="14" y="8" width="1" height="1" fill="#1a1a1a"/><rect x="14" y="9" width="1" height="1" fill="#2ee06a"/>', noseMarkup ) ); } /// @notice Full nose rect markup for a given idx, or empty string for None (idx 11 — ~10% uncommon). /// Each color (0–4) has a Flat (2×1) and Wide (2×2) shape; Clown Red (10) is Wide-only. function _noseMarkup(uint8 idx) internal pure returns (string memory) { if (idx == 11) return ""; string memory fill = _hex(_noseHex(idx)); if (_noseIsFlat(idx)) { return string(abi.encodePacked('<rect x="11" y="10" width="2" height="1" fill="#', fill, '"/>')); } return string(abi.encodePacked('<rect x="11" y="10" width="2" height="2" fill="#', fill, '"/>')); } /// @notice Even idx (0,2,4,6,8) = Flat shape; odd (1,3,5,7,9) = Wide; Clown Red (10) is always Wide. function _noseIsFlat(uint8 idx) internal pure returns (bool) { return idx < 10 && idx % 2 == 0; } function _noseHex(uint8 idx) internal pure returns (bytes3) { if (idx == 0 || idx == 1) return 0xba9a95; // Taupe if (idx == 2 || idx == 3) return 0xc4a484; // Light Brown if (idx == 4 || idx == 5) return 0x8d6e63; // Brown if (idx == 6 || idx == 7) return 0x5d4037; // Dark Brown if (idx == 8 || idx == 9) return 0xe8a0a8; // Pink return 0xe53935; // 10 — Clown Red (Wide-only) } function _wrapLayer(string memory inner, bool mutedBackdrop) internal pure returns (string memory) { string memory backdrop = mutedBackdrop ? '<rect width="24" height="24" fill="#d8dce3"/>' : ""; return string( abi.encodePacked( '<svg xmlns="http://www.w3.org/2000/svg" shape-rendering="crispEdges" viewBox="0 0 24 24" width="720" height="720">', backdrop, inner, "</svg>" ) ); } function _svgHair(uint8 style, string memory hair) internal pure returns (string memory) { if (style == 0) { // Classic Side — even left/right locks return string( abi.encodePacked( '<rect x="7" y="3" width="10" height="2" fill="#', hair, '"/><rect x="6" y="4" width="1" height="10" fill="#', hair, '"/><rect x="17" y="4" width="1" height="10" fill="#', hair, '"/><rect x="6" y="10" width="2" height="7" fill="#', hair, '"/><rect x="16" y="10" width="2" height="7" fill="#', hair, '"/>' ) ); } if (style == 1) { // Long Side — equal left/right length return string( abi.encodePacked( '<rect x="7" y="3" width="10" height="2" fill="#', hair, '"/><rect x="6" y="4" width="1" height="11" fill="#', hair, '"/><rect x="17" y="4" width="1" height="11" fill="#', hair, '"/>' ) ); } if (style == 2) { return string( abi.encodePacked( '<rect x="6" y="3" width="12" height="3" fill="#', hair, '"/><rect x="6" y="4" width="1" height="9" fill="#', hair, '"/><rect x="17" y="4" width="1" height="9" fill="#', hair, '"/>' ) ); } if (style == 3) { return string( abi.encodePacked( '<rect x="8" y="3" width="8" height="2" fill="#', hair, '"/><rect x="7" y="4" width="1" height="6" fill="#', hair, '"/><rect x="16" y="4" width="1" height="6" fill="#', hair, '"/>' ) ); } if (style == 4) { return string( abi.encodePacked( '<rect x="7" y="3" width="10" height="2" fill="#', hair, '"/><rect x="6" y="4" width="1" height="10" fill="#', hair, '"/><rect x="17" y="4" width="1" height="10" fill="#', hair, '"/><rect x="8" y="5" width="1" height="2" fill="#', hair, '"/><rect x="14" y="5" width="1" height="2" fill="#', hair, '"/>' ) ); } if (style == 5) { return string( abi.encodePacked( '<rect x="7" y="2" width="10" height="3" fill="#', hair, '"/><rect x="6" y="4" width="1" height="11" fill="#', hair, '"/><rect x="17" y="4" width="1" height="11" fill="#', hair, '"/>' ) ); } if (style == 6) return ""; // Bald — no hair pixels if (style == 7) return _svgRainbowAfroProposal(); // ultra rare flat-top rainbow return ""; } function _renderMouth(uint8 style) internal pure returns (string memory) { if (style == 0) return '<rect x="10" y="13" width="4" height="1" fill="#101010"/>'; // Neutral if (style == 1) { // Smirk — original T return '<rect x="10" y="13" width="4" height="1" fill="#101010"/><rect x="11" y="14" width="2" height="1" fill="#101010"/>'; } if (style == 2) { // Smile — classic U (replaces former Frown) return '<rect x="10" y="13" width="1" height="1" fill="#101010"/><rect x="13" y="13" width="1" height="1" fill="#101010"/><rect x="11" y="14" width="2" height="1" fill="#101010"/>'; } if (style == 3) { // Beard — chinstrap dark return '<rect x="10" y="13" width="4" height="1" fill="#101010"/><rect x="9" y="14" width="1" height="2" fill="#101010"/><rect x="14" y="14" width="1" height="2" fill="#101010"/><rect x="10" y="15" width="4" height="1" fill="#101010"/>'; } if (style == 4) return '<rect x="11" y="13" width="2" height="2" fill="#101010"/>'; // Open if (style == 5) { // Mustache — chevron. Wings are 2px tall (y11-12) so it stays flush against // both Flat (2x1, ends y10) and Wide (2x2, ends y11) noses — a fixed 1px wing // would leave a floating gap under the Flat nose. return '<rect x="9" y="11" width="1" height="2" fill="#101010"/><rect x="10" y="12" width="1" height="1" fill="#101010"/><rect x="11" y="13" width="2" height="1" fill="#101010"/><rect x="13" y="12" width="1" height="1" fill="#101010"/><rect x="14" y="11" width="1" height="2" fill="#101010"/>'; } if (style == 6) { // Blond Beard — rare: black mouth bar + blonde chinstrap (#e8c468) return '<rect x="10" y="13" width="4" height="1" fill="#101010"/><rect x="9" y="14" width="1" height="2" fill="#e8c468"/><rect x="14" y="14" width="1" height="2" fill="#e8c468"/><rect x="10" y="15" width="4" height="1" fill="#e8c468"/>'; } if (style == 7) { // Blonde Mustache — rare chevron, same taller-wing shape as idx 5. Wings are // blonde (#e8c468) but the center mouth-line pixel stays black, matching how // Blond Beard/Gray Beard keep a black mouth bar under the colored chinstrap. return '<rect x="9" y="11" width="1" height="2" fill="#e8c468"/><rect x="10" y="12" width="1" height="1" fill="#e8c468"/><rect x="11" y="13" width="2" height="1" fill="#101010"/><rect x="13" y="12" width="1" height="1" fill="#e8c468"/><rect x="14" y="11" width="1" height="2" fill="#e8c468"/>'; } if (style == 8) { // Gray Beard — rare: black mouth bar + gray chinstrap (#9aa0a6) return '<rect x="10" y="13" width="4" height="1" fill="#101010"/><rect x="9" y="14" width="1" height="2" fill="#9aa0a6"/><rect x="14" y="14" width="1" height="2" fill="#9aa0a6"/><rect x="10" y="15" width="4" height="1" fill="#9aa0a6"/>'; } if (style == 9) { // Gold Tooth — Smirk T + one gold pixel on the bar (super rare mouth) return '<rect x="10" y="13" width="2" height="1" fill="#101010"/><rect x="12" y="13" width="1" height="1" fill="#ffd700"/><rect x="13" y="13" width="1" height="1" fill="#101010"/><rect x="11" y="14" width="2" height="1" fill="#101010"/>'; } return '<rect x="10" y="13" width="4" height="1" fill="#101010"/>'; // Neutral fallback } function _renderFaceAccessory(uint8 acc) internal pure returns (string memory) { if (acc == 0) return ""; if (acc == 1) { // Rimless Glasses — crisp hollow wire frames (no stroke AA) + temple stubs return string( abi.encodePacked( '<rect x="8" y="7" width="3" height="1" fill="#c5d0dc"/><rect x="8" y="9" width="3" height="1" fill="#c5d0dc"/>', '<rect x="8" y="8" width="1" height="1" fill="#c5d0dc"/><rect x="10" y="8" width="1" height="1" fill="#c5d0dc"/>', '<rect x="13" y="7" width="3" height="1" fill="#c5d0dc"/><rect x="13" y="9" width="3" height="1" fill="#c5d0dc"/>', '<rect x="13" y="8" width="1" height="1" fill="#c5d0dc"/><rect x="15" y="8" width="1" height="1" fill="#c5d0dc"/>', '<rect x="11" y="8" width="2" height="1" fill="#aeb8c4"/>', '<rect x="7" y="8" width="1" height="1" fill="#aeb8c4"/><rect x="16" y="8" width="1" height="1" fill="#aeb8c4"/>' ) ); } if (acc == 2) { // Sunglasses — opaque lenses, chrome bridge, temple stubs return string( abi.encodePacked( '<rect x="8" y="7" width="3" height="2" fill="#0a0c10"/><rect x="13" y="7" width="3" height="2" fill="#0a0c10"/>', '<rect x="8" y="7" width="3" height="1" fill="#1c222a"/><rect x="13" y="7" width="3" height="1" fill="#1c222a"/>', '<rect x="11" y="7" width="2" height="1" fill="#5a6570"/>', '<rect x="7" y="7" width="1" height="1" fill="#2a3038"/><rect x="16" y="7" width="1" height="1" fill="#2a3038"/>' ) ); } if (acc == 3) { // 3D Glasses — anaglyph lenses + white bridge + temple stubs return string( abi.encodePacked( '<rect x="8" y="7" width="3" height="2" fill="#c62828"/><rect x="13" y="7" width="3" height="2" fill="#1565c0"/>', '<rect x="11" y="7" width="2" height="1" fill="#eceff4"/>', '<rect x="7" y="7" width="1" height="1" fill="#cfd3da"/><rect x="16" y="7" width="1" height="1" fill="#cfd3da"/>' ) ); } if (acc == 4) { // Halo removed — horns cover that headwear variation return ""; } if (acc == 5) { // Headset — left cup + left boom (museum dual-cup revert) return '<rect x="5" y="8" width="2" height="3" fill="#7f8ea3"/><rect x="5" y="7" width="3" height="1" fill="#cfd8e3"/><rect x="6" y="10" width="1" height="2" fill="#cfd8e3"/><rect x="6" y="11" width="3" height="1" fill="#cfd8e3"/><rect x="9" y="11" width="1" height="1" fill="#7f8ea3"/>'; } if (acc == 6) { // Monocle — crisp right-eye wire + brass drop chain return string( abi.encodePacked( '<rect x="13" y="7" width="3" height="1" fill="#c5d0dc"/><rect x="13" y="9" width="3" height="1" fill="#c5d0dc"/>', '<rect x="13" y="8" width="1" height="1" fill="#c5d0dc"/><rect x="15" y="8" width="1" height="1" fill="#c5d0dc"/>', '<rect x="14" y="8" width="1" height="1" fill="#d8e1ea"/>', '<rect x="16" y="8" width="1" height="1" fill="#c9a227"/>', '<rect x="16" y="9" width="1" height="1" fill="#e9bf52"/><rect x="16" y="10" width="1" height="1" fill="#c9a227"/>' ) ); } if (acc == 7) { // Devil Horns — small hooked curl (anchors at hairline, sweeps out, curls back // to a point) so the silhouette reads as a curved horn, not a straight sweep // like Bull Horns. Blood curl colorway (approved): near-black stalk -> crimson tip. return string( abi.encodePacked( '<rect x="6" y="4" width="1" height="1" fill="#141010"/>', '<rect x="5" y="3" width="1" height="1" fill="#0c0a0a"/>', '<rect x="5" y="2" width="1" height="1" fill="#080606"/>', '<rect x="6" y="1" width="1" height="1" fill="#4a0a0a"/>', '<rect x="6" y="0" width="1" height="1" fill="#c62828"/>', '<rect x="17" y="4" width="1" height="1" fill="#141010"/>', '<rect x="18" y="3" width="1" height="1" fill="#0c0a0a"/>', '<rect x="18" y="2" width="1" height="1" fill="#080606"/>', '<rect x="17" y="1" width="1" height="1" fill="#4a0a0a"/>', '<rect x="17" y="0" width="1" height="1" fill="#c62828"/>' ) ); } if (acc == 8) { // Eye Patch — full left-eye cover (whites are y=8–9) + face-only brow strap // Skin is x=7..16; hair columns sit at x=6 / x=17 — strap stays on skin. return string( abi.encodePacked( '<rect x="7" y="7" width="10" height="1" fill="#1a1e24"/>', '<rect x="8" y="7" width="3" height="3" fill="#0a0c10"/>' ) ); } if (acc == 9) { // Crown — Centered Five Ruby (locked): hair-aligned band + ruby @ 11–12 return _svgCrownVariant(12, false); } if (acc == 10) { // Bull Horns — full ivory curve (approved colorway C) return string( abi.encodePacked( '<rect x="5" y="4" width="2" height="1" fill="#8d6e63"/>', '<rect x="4" y="3" width="2" height="1" fill="#bcaaa4"/>', '<rect x="3" y="2" width="2" height="1" fill="#e8dcc8"/>', '<rect x="2" y="1" width="1" height="1" fill="#fff8e7"/>', '<rect x="17" y="4" width="2" height="1" fill="#8d6e63"/>', '<rect x="18" y="3" width="2" height="1" fill="#bcaaa4"/>', '<rect x="19" y="2" width="2" height="1" fill="#e8dcc8"/>', '<rect x="21" y="1" width="1" height="1" fill="#fff8e7"/>' ) ); } if (acc == 11) { // Bluetooth Headset — navy cups + titanium boom (right); no LED cyan return string( abi.encodePacked( '<rect x="5" y="8" width="2" height="3" fill="#1a2433"/><rect x="5" y="7" width="3" height="1" fill="#2b3a4d"/>', '<rect x="17" y="8" width="2" height="3" fill="#1a2433"/><rect x="16" y="7" width="3" height="1" fill="#2b3a4d"/>', '<rect x="17" y="10" width="1" height="2" fill="#8a96a5"/><rect x="15" y="11" width="3" height="1" fill="#9aa8b5"/>', '<rect x="14" y="11" width="1" height="1" fill="#b8c0cb"/>' ) ); } if (acc == 12) { // Gold Headset — same left-boom silhouette as Headset, gold finish (~1% super rare) return '<rect x="5" y="8" width="2" height="3" fill="#c9a227"/><rect x="5" y="7" width="3" height="1" fill="#f5d36b"/><rect x="6" y="10" width="1" height="2" fill="#e9bf52"/><rect x="6" y="11" width="3" height="1" fill="#f5d36b"/><rect x="9" y="11" width="1" height="1" fill="#ffe08a"/>'; } if (acc == 13) { // Golden Devil Horns — solid gold stalk (#f5d36b), red tip kept (~1% super rare) return string( abi.encodePacked( '<rect x="6" y="4" width="1" height="1" fill="#f5d36b"/>', '<rect x="5" y="3" width="1" height="1" fill="#f5d36b"/>', '<rect x="5" y="2" width="1" height="1" fill="#f5d36b"/>', '<rect x="6" y="1" width="1" height="1" fill="#f5d36b"/>', '<rect x="6" y="0" width="1" height="1" fill="#c62828"/>', '<rect x="17" y="4" width="1" height="1" fill="#f5d36b"/>', '<rect x="18" y="3" width="1" height="1" fill="#f5d36b"/>', '<rect x="18" y="2" width="1" height="1" fill="#f5d36b"/>', '<rect x="17" y="1" width="1" height="1" fill="#f5d36b"/>', '<rect x="17" y="0" width="1" height="1" fill="#c62828"/>' ) ); } if (acc == 14) { // Golden Bull Horns — same wide outward curve, gold gradient (matches Gold Headset finish, ~1% super rare) return string( abi.encodePacked( '<rect x="5" y="4" width="2" height="1" fill="#c9a227"/>', '<rect x="4" y="3" width="2" height="1" fill="#e9bf52"/>', '<rect x="3" y="2" width="2" height="1" fill="#f5d36b"/>', '<rect x="2" y="1" width="1" height="1" fill="#ffe08a"/>', '<rect x="17" y="4" width="2" height="1" fill="#c9a227"/>', '<rect x="18" y="3" width="2" height="1" fill="#e9bf52"/>', '<rect x="19" y="2" width="2" height="1" fill="#f5d36b"/>', '<rect x="21" y="1" width="1" height="1" fill="#ffe08a"/>' ) ); } if (acc == 15) { // Blue Boom Headset — single right cup + blue boom (not dual-cup) return string( abi.encodePacked( '<rect x="17" y="8" width="2" height="3" fill="#1a2433"/><rect x="16" y="7" width="3" height="1" fill="#2b3a4d"/>', '<rect x="17" y="10" width="1" height="2" fill="#1e5fd9"/><rect x="15" y="11" width="3" height="1" fill="#2b76ff"/>', '<rect x="14" y="11" width="1" height="1" fill="#7fb4ff"/>' ) ); } if (acc == 16) { // Balding Cap — rejected return ""; } if (acc == 17) { // Top Hat — rejected return ""; } if (acc == 18) { // Gold Rims — rimless silhouette in Gold Headset finish (~1%) return string( abi.encodePacked( '<rect x="8" y="7" width="3" height="1" fill="#f5d36b"/><rect x="8" y="9" width="3" height="1" fill="#e9bf52"/>', '<rect x="8" y="8" width="1" height="1" fill="#f5d36b"/><rect x="10" y="8" width="1" height="1" fill="#f5d36b"/>', '<rect x="13" y="7" width="3" height="1" fill="#f5d36b"/><rect x="13" y="9" width="3" height="1" fill="#e9bf52"/>', '<rect x="13" y="8" width="1" height="1" fill="#f5d36b"/><rect x="15" y="8" width="1" height="1" fill="#f5d36b"/>', '<rect x="11" y="8" width="2" height="1" fill="#ffe08a"/>', '<rect x="7" y="8" width="1" height="1" fill="#c9a227"/><rect x="16" y="8" width="1" height="1" fill="#c9a227"/>' ) ); } if (acc == 19) { // Banded Frameless — OG stroke rimless + temple bands ending at hair // Default (most hairstyles): hair columns sit at x=6 / x=17. return _svgBandedFrameless(0, "d8e1ea"); } if (acc == 21) { // Gold Banded Frameless — same silhouette, gold finish (~1% super rare) return _svgBandedFrameless(0, "f5d36b"); } // 20 Black Monocle — declined return ""; } /// @notice Banded Frameless frames + hairstyle-aware temple bands so the bands /// always stop exactly at the hairline instead of floating past a narrower head. /// bandMode: 0 = default (hair at x=6/x=17), 1 = Short Crop (hair at x=7/x=16), /// 2 = no side hair to meet (Bald / Rainbow Afro) — frames only, no temple bands. /// col: stroke/fill hex without '#' — "d8e1ea" silver (idx 19) or "f5d36b" gold (idx 21). function _svgBandedFrameless(uint8 bandMode, string memory col) internal pure returns (string memory) { string memory frames = string( abi.encodePacked( '<rect x="8" y="7" width="3" height="3" fill="none" stroke="#', col, '" stroke-width="0.4"/>', '<rect x="13" y="7" width="3" height="3" fill="none" stroke="#', col, '" stroke-width="0.4"/>', '<rect x="11" y="8" width="2" height="1" fill="#', col, '"/>' ) ); if (bandMode == 2) return frames; if (bandMode == 1) { // Short Crop — only 1px of skin between lens and hair; band ends flush with hair. return string( abi.encodePacked( frames, '<rect x="7" y="8" width="1" height="1" fill="#', col, '"/><rect x="16" y="8" width="1" height="1" fill="#', col, '"/>' ) ); } return string( abi.encodePacked( frames, '<rect x="6" y="8" width="2" height="1" fill="#', col, '"/><rect x="16" y="8" width="2" height="1" fill="#', col, '"/>' ) ); } function _renderFaceAccessoryForHair(uint8 acc, uint8 hairStyle) internal pure returns (string memory) { if (acc == 9 && hairStyle == 6) return _svgCrownOnBald(); if (acc == 9 && hairStyle == 7) return _svgCrownOnAfro(); if (acc == 19 || acc == 21) { string memory col = acc == 21 ? "f5d36b" : "d8e1ea"; if (hairStyle == 3) return _svgBandedFrameless(1, col); // Short Crop if (hairStyle == 6 || hairStyle == 7) return _svgBandedFrameless(2, col); // Bald / Rainbow Afro } return _renderFaceAccessory(acc); } function _renderBrokerBadge(uint8 badge) internal pure returns (string memory) { if (badge == 0) return ""; // Lapel pin — outer chest, clear of the tie knot (was x=14 next to tie) if (badge == 1) { return '<rect x="16" y="20" width="2" height="2" fill="#24a148"/><rect x="16" y="20" width="2" height="1" fill="#86efac"/>'; } if (badge == 2) { return '<rect x="16" y="20" width="2" height="2" fill="#2b3fd1"/><rect x="17" y="20" width="1" height="1" fill="#8fb8ff"/>'; } // Diamond Hands — facet highlight return '<rect x="16" y="20" width="1" height="1" fill="#a8f7ff"/><rect x="17" y="20" width="1" height="1" fill="#00e5ff"/><rect x="16" y="21" width="2" height="1" fill="#00b8cc"/>'; } function _renderPocketSquare(uint8 sq) internal pure returns (string memory) { if (sq == 0) return ""; string memory tip; string memory fold; if (sq == 1) { tip = "f5f0e6"; fold = "e8dcc8"; } else if (sq == 2) { tip = "ffffff"; fold = "d8dce3"; } else { tip = "f5d36b"; fold = "e9bf52"; } // Complete 2×2 breast pocket — mid-jacket (y=21–22), tip + fold row return string( abi.encodePacked( '<rect x="6" y="21" width="2" height="1" fill="#', tip, '"/><rect x="6" y="22" width="2" height="1" fill="#', fold, '"/>' ) ); } function _pickBackground(uint8 idx) internal pure returns (bytes3) { if (idx == 0) return 0x6ca0dc; if (idx == 1) return 0x8dbfe8; if (idx == 2) return 0xb8d2e8; if (idx == 3) return 0xd0b090; if (idx == 4) return 0x9bb0c8; if (idx == 5) return 0x7f92a8; if (idx == 6) return 0x2d6a4f; return 0xff6f00; } function _pickSuit(uint8 idx) internal pure returns (bytes3) { if (idx == 0) return 0x1f2328; if (idx == 1) return 0x1a3352; // Navy — clearer blue if (idx == 2) return 0x3a4a52; // Slate — cooler gray if (idx == 3) return 0x4a5568; // Steel — lighter separation if (idx == 4) return 0x4a235a; if (idx == 5) return 0x1f6b3a; // Forest green (replaces Dark Teal) if (idx == 6) return 0xe53935; // Rainbow swatch if (idx == 7) return 0xff4d94; // Pink if (idx == 8) return 0xc62828; // Red solid ~1% rare return 0xc62828; // unused idx 9 } function _pickTie(uint8 idx) internal pure returns (bytes3) { if (idx == 0) return 0x4f8cff; if (idx == 1) return 0x24a148; if (idx == 2) return 0xe53935; if (idx == 3) return 0xf4b400; if (idx == 4) return 0x6f42c1; return 0x00a3a3; } function _pickSkin(uint8 idx) internal pure returns (bytes3) { if (idx == 0) return 0xf1c27d; if (idx == 1) return 0xe0ac69; if (idx == 2) return 0xc68642; if (idx == 3) return 0x8d5524; if (idx == 4) return 0xffdbac; if (idx == 5) return 0xd9a066; if (idx == 6) return 0xd63f36; if (idx == 7) return 0x63b35f; if (idx == 8) return 0xa7b0ba; if (idx == 9) return 0xfaf8f4; if (idx == 10) return 0x7cf08a; if (idx == 11) return 0xf5d36b; return 0x2b2d42; } function _pickEye(uint8 idx) internal pure returns (bytes3) { if (idx == 0) return 0x2b3fd1; if (idx == 1) return 0x4b8f29; if (idx == 2) return 0x7d5534; if (idx == 3) return 0x5b6678; if (idx == 4) return 0x1f7a8c; if (idx == 5) return 0x8a4fff; if (idx == 6) return 0xb5651d; return 0x1d3557; } function _pickHairColor(uint8 idx) internal pure returns (bytes3) { // Distinct palette — no identical or near-identical hexes. if (idx == 0) return 0x111111; // Jet Black if (idx == 1) return 0x3e2723; // Dark Brown if (idx == 2) return 0x5d4037; // Brown if (idx == 3) return 0xb08968; // Light Brown if (idx == 4) return 0x607d8b; // Charcoal cool slate if (idx == 5) return 0x8d7b6a; // Gray Brown return 0xe8c468; // Blonde } function _hex(bytes3 data) internal pure returns (string memory) { bytes memory alphabet = "0123456789abcdef"; bytes memory str = new bytes(6); for (uint256 i = 0; i < 3; i++) { str[i * 2] = alphabet[uint8(data[i] >> 4)]; str[i * 2 + 1] = alphabet[uint8(data[i] & 0x0f)]; } return string(str); } // --- Trait catalog (audit PNG export; trait-specific, not token-specific) --- function catalogBackground(uint8 idx) external pure returns (string memory) { return _wrapLayer( string(abi.encodePacked('<rect width="24" height="24" fill="#', _hex(_pickBackground(idx)), '"/>')), false ); } function catalogSkin(uint8 idx) external pure returns (string memory) { return _wrapLayer(_svgSkinNeck(_hex(_pickSkin(idx)), idx, 0), true); } function catalogHair(uint8 style, uint8 color) external pure returns (string memory) { return _wrapLayer(_svgHair(style, _hex(_pickHairColor(color))), true); } function catalogHairStyle(uint8 style) external pure returns (string memory) { return _wrapLayer(_svgHair(style, _hex(_pickHairColor(1))), true); } function catalogHairColor(uint8 color) external pure returns (string memory) { return _wrapLayer(_svgHair(0, _hex(_pickHairColor(color))), true); } function catalogEyes(uint8 idx) external pure returns (string memory) { return _wrapLayer(_eyeMarkup(idx, _noseMarkup(0)), true); } function catalogMouth(uint8 idx) external pure returns (string memory) { return _wrapLayer(_renderMouth(idx), true); } function catalogFaceAccessory(uint8 idx) external pure returns (string memory) { return _wrapLayer(_renderFaceAccessory(idx), true); } /// @notice Full composite with forced face accessory (QA / headset proposals). function renderWithFaceAccessoryOverride( uint256 tokenId, uint256 traitSeed, uint8 faceAccessory ) external pure returns (string memory) { return renderWithOverrides(tokenId, traitSeed, 255, 255, faceAccessory); } /// @notice Full composite with forced mouth (QA / Gold Tooth). function renderWithMouthOverride( uint256 tokenId, uint256 traitSeed, uint8 mouth ) external pure returns (string memory) { return renderWithOverrides(tokenId, traitSeed, 255, mouth, 255); } /// @notice Full composite with forced nose color (QA / Clown Red). function renderWithNoseOverride( uint256 /* tokenId */, uint256 traitSeed, uint8 noseColor ) external pure returns (string memory) { StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); string memory bg = _hex(_pickBackground(t.background)); string memory tie = _hex(_pickTie(t.tie)); string memory skin = _hex(_pickSkin(t.skin)); string memory hair = _hex(_pickHairColor(t.hairColor)); string memory nose = _noseMarkup(noseColor); return string( abi.encodePacked( _svgHead(bg), _svgSkinNeck(skin, t.skin, t.hairStyle), _svgHair(t.hairStyle, hair), _eyeMarkup(t.eyeColor, nose), _renderMouth(t.mouth), _bodyForSuit(t.suit, tie, t.neckwear), _renderPocketSquare(t.pocketSquare), _renderFaceAccessoryForHair(t.faceAccessory, t.hairStyle), _renderBrokerBadge(t.brokerBadge), "</svg>" ) ); } /// @notice Nose layer for QA catalog. Idx 11 = None (empty, shown as ghost outline). function catalogNose(uint8 idx) external pure returns (string memory) { if (idx == 11) { return _wrapLayer('<rect x="10" y="9" width="4" height="4" fill="none" stroke="#8b95a8" stroke-width="0.25"/>', true); } return _wrapLayer(_noseMarkup(idx), true); } /// @notice QA composite overrides. Pass 255 to keep decoded trait for that slot. function renderWithOverrides( uint256 /* tokenId */, uint256 traitSeed, uint8 hairStyleOr255, uint8 mouthOr255, uint8 faceAccessoryOr255 ) public pure returns (string memory) { StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); uint8 hairStyle = hairStyleOr255 == 255 ? t.hairStyle : hairStyleOr255; uint8 mouth = mouthOr255 == 255 ? t.mouth : mouthOr255; uint8 faceAccessory = faceAccessoryOr255 == 255 ? t.faceAccessory : faceAccessoryOr255; string memory bg = _hex(_pickBackground(t.background)); string memory tie = _hex(_pickTie(t.tie)); string memory skin = _hex(_pickSkin(t.skin)); string memory hair = _hex(_pickHairColor(t.hairColor)); return string( abi.encodePacked( _svgHead(bg), _svgSkinNeck(skin, t.skin, hairStyle), _svgHair(hairStyle, hair), _eyeMarkup(t.eyeColor, _noseMarkup(t.noseColor)), _renderMouth(mouth), _bodyForSuit(t.suit, tie, t.neckwear), _renderPocketSquare(t.pocketSquare), _renderFaceAccessoryForHair(faceAccessory, hairStyle), _renderBrokerBadge(t.brokerBadge), "</svg>" ) ); } function catalogBrokerBadge(uint8 idx) external pure returns (string memory) { return _wrapLayer(_renderBrokerBadge(idx), true); } function catalogBody(uint8 suit, uint8 tie, uint8 neckwear) external pure returns (string memory) { return _wrapLayer( _bodyForSuit(suit, _hex(_pickTie(tie)), neckwear), true ); } function catalogSuit(uint8 suit) external pure returns (string memory) { return _wrapLayer(_bodyForSuit(suit, _hex(_pickTie(0)), 0), true); } function catalogTie(uint8 tie) external pure returns (string memory) { return _wrapLayer(_svgBody(_hex(_pickSuit(0)), _hex(_pickTie(tie)), 0), true); } function catalogNeckwear(uint8 neckwear) external pure returns (string memory) { return _wrapLayer(_svgBody(_hex(_pickSuit(0)), _hex(_pickTie(0)), neckwear), true); } /// @notice Super-rare proposal — multicolor rainbow afro (not in V6 roll table yet). function catalogRainbowAfroProposal() external pure returns (string memory) { return _wrapLayer(_svgRainbowAfroProposal(), true); } /// @notice Rainbow afro on a neutral face for art review. function catalogRainbowAfroFaceContext() external pure returns (string memory) { return _wrapLayer( string( abi.encodePacked( _svgSkinNeck(_hex(_pickSkin(0)), 0, 0), _svgRainbowAfroProposal(), _eyeMarkup(0, _noseMarkup(0)), _renderMouth(1) ) ), true ); } /// @notice Bald hair style layer (empty). function catalogBaldProposal() external pure returns (string memory) { return _wrapLayer("", true); } /// @notice Proposal: Classic Side with equal left/right locks (not applied until approved). function catalogClassicSideEvenProposal() external pure returns (string memory) { string memory hair = _hex(_pickHairColor(1)); return _wrapLayer( string( abi.encodePacked( '<rect x="7" y="3" width="10" height="2" fill="#', hair, '"/><rect x="6" y="4" width="1" height="10" fill="#', hair, '"/><rect x="17" y="4" width="1" height="10" fill="#', hair, '"/><rect x="6" y="10" width="2" height="7" fill="#', hair, '"/><rect x="16" y="10" width="2" height="7" fill="#', hair, '"/>' ) ), true ); } /// @notice Proposal: Long Side with equal left/right length (not applied until approved). function catalogLongSideEvenProposal() external pure returns (string memory) { string memory hair = _hex(_pickHairColor(1)); return _wrapLayer( string( abi.encodePacked( '<rect x="7" y="3" width="10" height="2" fill="#', hair, '"/><rect x="6" y="4" width="1" height="11" fill="#', hair, '"/><rect x="17" y="4" width="1" height="11" fill="#', hair, '"/>' ) ), true ); } /// @notice Bald on a neutral face for art review (no hair rects). function catalogBaldFaceContext() external pure returns (string memory) { return _wrapLayer( string( abi.encodePacked( _svgSkinNeck(_hex(_pickSkin(0)), 0, 6), _eyeMarkup(0, _noseMarkup(0)), _renderMouth(1) ) ), true ); } /// @notice Full composite preview with hair omitted (Bald proposal QA; not in roll table). function renderBaldPreview(uint256 /* tokenId */, uint256 traitSeed) external pure returns (string memory) { StonkBrokerTraitsV6Proposal.Traits memory t = StonkBrokerTraitsV6Proposal.decode(traitSeed); string memory bg = _hex(_pickBackground(t.background)); string memory tie = _hex(_pickTie(t.tie)); string memory skin = _hex(_pickSkin(t.skin)); return string( abi.encodePacked( _svgHead(bg), _svgFaceBald(t, skin, ""), _bodyForSuit(t.suit, tie, t.neckwear), _renderPocketSquare(t.pocketSquare), _renderFaceAccessoryBald(t.faceAccessory), _renderBrokerBadge(t.brokerBadge), "</svg>" ) ); } function _svgFaceBald( StonkBrokerTraitsV6Proposal.Traits memory t, string memory skin, string memory /* eye */ ) internal pure returns (string memory) { return string( abi.encodePacked( _svgSkinNeck(skin, t.skin, 6), // force Bald ears _eyeMarkup(t.eyeColor, _noseMarkup(t.noseColor)), _renderMouth(t.mouth) ) ); } /// @notice Crown variants for museum review. `bald` drops silhouette +1px. /// 0–6 original pack · 10–16 centered pack (hair-aligned x=7..16, ruby options) function _svgCrownVariant(uint8 v, bool bald) internal pure returns (string memory) { if (v >= 10) return _svgCrownCentered(v - 10, bald); string memory y0 = bald ? "1" : "0"; string memory y1 = bald ? "2" : "1"; string memory y2 = bald ? "3" : "2"; if (v == 1) { // Five Peak — wider royal band, five tips centered on x=12 return string( abi.encodePacked( _crownPx("8", y0, "ffe08a"), _crownPx("10", y0, "ffe08a"), _crownPx("12", y0, "ffe08a"), _crownPx("14", y0, "ffe08a"), _crownPx("16", y0, "ffe08a"), _crownBar("7", y1, "11", "f5d36b"), _crownBar("8", y2, "9", "e9bf52") ) ); } if (v == 2) { // Tiara — lighter, narrower band, three delicate tips return string( abi.encodePacked( _crownPx("9", y0, "ffe08a"), _crownPx("12", y0, "fff6c8"), _crownPx("15", y0, "ffe08a"), _crownBar("9", y1, "7", "f5d36b"), _crownBar("10", y2, "5", "e9bf52") ) ); } if (v == 3) { // Ruby Peak — classic tri with blood-ruby center tip (echo Devil Horn tip) return string( abi.encodePacked( _crownPx("9", y0, "ffe08a"), _crownPx("12", y0, "c62828"), _crownPx("15", y0, "ffe08a"), _crownBar("8", y1, "9", "f5d36b"), _crownPx("12", y1, "ffe08a"), _crownBar("9", y2, "7", "e9bf52") ) ); } if (v == 4) { // Empire Band — double gold rail, three tips return string( abi.encodePacked( _crownPx("9", y0, "ffe08a"), _crownPx("12", y0, "ffe08a"), _crownPx("15", y0, "ffe08a"), _crownBar("8", y1, "9", "f5d36b"), _crownBar("8", y2, "9", "c9a227") ) ); } if (v == 5) { // Arch Gate — raised side tips, soft center dip return string( abi.encodePacked( _crownPx("8", y0, "ffe08a"), _crownPx("16", y0, "ffe08a"), _crownPx("9", y1, "f5d36b"), _crownPx("15", y1, "f5d36b"), _crownBar("10", y1, "5", "e9bf52"), _crownBar("9", y2, "7", "c9a227") ) ); } if (v == 6) { // Broker Block — chunky center bar tip (king of the desk) return string( abi.encodePacked( _crownPx("8", y0, "ffe08a"), _crownBar("11", y0, "3", "ffe08a"), _crownPx("16", y0, "ffe08a"), _crownBar("8", y1, "9", "f5d36b"), _crownBar("9", y2, "7", "e9bf52") ) ); } // 0 Classic Tri — odd band + tips @ 9/12/15 return string( abi.encodePacked( _crownPx("9", y0, "ffe08a"), _crownPx("12", y0, "ffe08a"), _crownPx("15", y0, "ffe08a"), _crownBar("8", y1, "9", "f5d36b"), _crownBar("9", y2, "7", "e9bf52") ) ); } /// @notice Centered crowns — band matches hair top (x=7 w=10); ruby straddles midline (x=11–12). /// 0 Tri Gold · 1 Tri Ruby · 2 Five Ruby · 3 Tiara Ruby · 4 Empire Ruby · 5 Arch Ruby · 6 Block Ruby function _svgCrownCentered(uint8 v, bool bald) internal pure returns (string memory) { string memory y0 = bald ? "1" : "0"; string memory y1 = bald ? "2" : "1"; string memory y2 = bald ? "3" : "2"; string memory rail = string( abi.encodePacked(_crownBar("7", y1, "10", "f5d36b"), _crownBar("8", y2, "8", "e9bf52")) ); if (v == 0) { return string( abi.encodePacked( _crownPx("8", y0, "ffe08a"), _crownBar("11", y0, "2", "ffe08a"), _crownPx("15", y0, "ffe08a"), rail ) ); } if (v == 1) { // Tri Ruby — favorite ruby accent, hair-centered (inlay after rail so it sits on band) return string( abi.encodePacked( _crownPx("8", y0, "ffe08a"), _

src/launch-nft/libraries/StonkBrokerTraitsV6Proposal.sol

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; /// @notice V6 proposal — Devil Horns (acc 7), Bull Horns (acc 10), Gold Smile mouth (~1%). /// Same trait roll weights and dedup mechanics; new seed domain for side-by-side safety. library StonkBrokerTraitsV6Proposal { struct Traits { uint8 background; uint8 skin; uint8 hairStyle; uint8 hairColor; uint8 eyeColor; uint8 noseColor; // 0–9 five colors × Flat/Wide shape; 10 Clown Red (Wide-only) ~1%; 11 None ~10% uncommon uint8 mouth; uint8 suit; uint8 tie; uint8 neckwear; uint8 faceAccessory; uint8 brokerBadge; uint8 pocketSquare; // 0 none; 1 cream / 2 white / 3 gold — ~1% ultra rare } uint256 internal constant MAX_SEED_ATTEMPTS = 256; function candidateSeed(uint256 tokenId, uint256 attempt) internal pure returns (uint256) { return uint256(keccak256(abi.encodePacked("STONK_TRAIT_V6", tokenId, attempt))); } function decode(uint256 seed) internal pure returns (Traits memory t) { t.background = uint8(seed % 8); t.skin = uint8((seed / 5) % 13); // Hair: common 0–5 + Bald (6); Rainbow Afro (7) ~0.1% ultra rare (1/1000). { uint16 hairRoll = uint16((seed / 11) % 1000); if (hairRoll == 0) { t.hairStyle = 7; // Rainbow Afro } else { t.hairStyle = uint8((hairRoll - 1) % 7); // Classic Side..Bald } } t.hairColor = uint8((seed / 17) % 7); // Eyes: 8 standard colors (0–7); Bull Candle (8) ~1% super rare — green candlestick // bar eyes replacing the pupil, layered above whichever base color would have rolled. if ((seed / 89) % 100 == 0) { t.eyeColor = 8; // Bull Candle } else { t.eyeColor = uint8((seed / 23) % 8); } // Nose: 5 colors × Flat/Wide (0–9, even=Flat/odd=Wide); Clown Red Wide-only (10) ~1%; // None (11) ~10% fairly uncommon. Black removed. { uint8 noseRoll = uint8((seed / 31) % 100); if (noseRoll == 0) { t.noseColor = 10; // Clown Red — Wide only } else if (noseRoll <= 10) { t.noseColor = 11; // None — no nose pixels } else { t.noseColor = uint8((noseRoll - 11) % 10); // Taupe..Pink, Flat/Wide } } // Mouth: commons 0–5; rares Blond Beard/Mustache/Gray Beard ~3% each; // Gold Tooth (9) ~1% super rare — Smirk + one gold tooth pixel. if ((seed / 67) % 100 == 0) { t.mouth = 9; // Gold Tooth } else { uint8 mouthRoll = uint8((seed / 29) % 100); if (mouthRoll < 3) { t.mouth = 6; // Blond Beard } else if (mouthRoll < 6) { t.mouth = 7; // Blonde Mustache } else if (mouthRoll < 9) { t.mouth = 8; // Gray Beard } else { t.mouth = uint8((mouthRoll - 9) % 6); // Neutral..Mustache } } // Suit: common 0–5; Rainbow (6) ~1%; Pink (7) ~0.5%; Red solid (8) ~1% rare. { uint8 suitRoll = uint8((seed / 37) % 200); if (suitRoll < 2) { t.suit = 6; // Rainbow (super rare) } else if (suitRoll == 2) { t.suit = 7; // Pink (ultra rare) } else if (suitRoll <= 4) { t.suit = 8; // Red solid (rare) — rolls 3–4 → ~1% } else { t.suit = uint8((suitRoll - 5) % 6); // Charcoal..Forest (green) } } t.tie = uint8((seed / 41) % 6); t.neckwear = uint8((seed / 45) % 4) == 0 ? 1 : 0; t.brokerBadge = uint8((seed / 49) % 8); if (t.brokerBadge > 3) t.brokerBadge = 0; // Pocket square ~1% ultra rare (cream / white / gold). if ((seed / 53) % 100 == 0) { t.pocketSquare = uint8(1 + ((seed / 59) % 3)); } else { t.pocketSquare = 0; } // Gold Headset / Golden Devil / Golden Bull / Gold Rims / Gold Banded Frameless — ~1% each. if ((seed / 61) % 100 == 0) { t.faceAccessory = 12; } else if ((seed / 73) % 100 == 0) { t.faceAccessory = 13; // Golden Devil Horns } else if ((seed / 79) % 100 == 0) { t.faceAccessory = 14; // Golden Bull Horns } else if ((seed / 71) % 100 == 0) { t.faceAccessory = 18; // Gold Rims } else if ((seed / 83) % 100 == 0) { t.faceAccessory = 21; // Gold Banded Frameless } else { uint8 accRoll = uint8((seed / 43) % 40); if (accRoll == 0) t.faceAccessory = 0; else if (accRoll == 1) t.faceAccessory = 1; else if (accRoll == 2) t.faceAccessory = 2; else if (accRoll == 3) t.faceAccessory = 3; // Halo (was 4) removed — horns cover that head-variation slot else if (accRoll == 4) t.faceAccessory = 0; else if (accRoll <= 10) t.faceAccessory = 5; // Headset (slate, left boom) else if (accRoll <= 15) t.faceAccessory = 11; // Bluetooth Headset (navy, titanium boom) else if (accRoll <= 17) t.faceAccessory = 15; // Blue Boom Headset (navy, blue boom) — ~5% else if (accRoll == 18) t.faceAccessory = 6; else if (accRoll == 19) t.faceAccessory = 7; // Devil Horns else if (accRoll == 20) t.faceAccessory = 8; else if (accRoll <= 23) t.faceAccessory = 9; // Crown else if (accRoll <= 26) t.faceAccessory = 10; // Bull Horns else { // 27–39 (13 rolls): None/glasses rotation + Banded Frameless every 5th (~6.5%) uint8 tailRoll = accRoll % 5; t.faceAccessory = tailRoll == 4 ? 19 : tailRoll; // 19 = Banded Frameless } } } function traitSignature(uint256 seed) internal pure returns (bytes32) { Traits memory t = decode(seed); return keccak256( abi.encodePacked( t.background, t.skin, t.hairStyle, t.hairColor, t.eyeColor, t.noseColor, t.mouth, t.suit, t.tie, t.neckwear, t.faceAccessory, t.brokerBadge, t.pocketSquare ) ); } function skinName(uint8 skin) internal pure returns (string memory) { if (skin <= 5) return "Human"; if (skin == 6) return "Devil"; if (skin == 7) return "Zombie"; if (skin == 8) return "Robot"; if (skin == 9) return "Marshmallow"; if (skin == 10) return "Alien"; if (skin == 11) return "Lemon"; return "Shadow"; } function hairStyleName(uint8 style) internal pure returns (string memory) { if (style == 0) return "Classic Side"; if (style == 1) return "Long Side"; if (style == 2) return "Wide Top"; if (style == 3) return "Short Crop"; if (style == 4) return "Wavy"; if (style == 5) return "Tall"; if (style == 6) return "Bald"; return "Rainbow Afro"; // 7 — ultra rare } /// @notice Names for the 8 eye colors rendered by _pickEye() in the SVG renderer, plus the /// super-rare Bull Candle eye style (8) which is a distinct shape, not a color swatch. function eyeColorName(uint8 color) internal pure returns (string memory) { if (color == 0) return "Blue"; // 0x2b3fd1 if (color == 1) return "Green"; // 0x4b8f29 if (color == 2) return "Brown"; // 0x7d5534 if (color == 3) return "Slate Gray"; // 0x5b6678 if (color == 4) return "Teal"; // 0x1f7a8c if (color == 5) return "Violet"; // 0x8a4fff if (color == 6) return "Amber"; // 0xb5651d if (color == 7) return "Navy"; // 0x1d3557 return "Bull Candle"; // 8 — ~1% super rare, green candlestick bar eyes } function hairColorName(uint8 color) internal pure returns (string memory) { if (color == 0) return "Jet Black"; if (color == 1) return "Dark Brown"; if (color == 2) return "Brown"; if (color == 3) return "Light Brown"; if (color == 4) return "Charcoal"; if (color == 5) return "Gray Brown"; return "Blonde"; } /// @notice Metadata-facing Hair Color, aware of hairStyle. The raw `hairColor` roll is still /// decoded and stored for every token (it drives the SVG hair layer where relevant), but it /// is cosmetically meaningless for Bald (no hair to color) and for Rainbow Afro (multicolor, /// not a single swatch) — listing e.g. "Charcoal" on a Bald broker or one fixed color on a /// Rainbow Afro read as data glitches on marketplaces. Bald reports "None" (and is dropped /// from the attributes array entirely by the renderer's `_attr` helper); Rainbow Afro reports /// "Rainbow" instead of the underlying roll. function hairColorNameForMetadata(uint8 hairStyle, uint8 color) internal pure returns (string memory) { if (hairStyle == 6) return "None"; // Bald if (hairStyle == 7) return "Rainbow"; // Rainbow Afro — ultra rare return hairColorName(color); } function faceAccessoryName(uint8 acc) internal pure returns (string memory) { if (acc == 0) return "None"; if (acc == 1) return "Rimless Glasses"; if (acc == 2) return "Sunglasses"; if (acc == 3) return "3D Glasses"; if (acc == 4) return "None"; // Halo removed — index retired if (acc == 5) return "Headset"; // slate dual cups, left boom if (acc == 6) return "Monocle"; if (acc == 7) return "Devil Horns"; if (acc == 8) return "Eye Patch"; if (acc == 9) return "Crown"; if (acc == 10) return "Bull Horns"; if (acc == 11) return "Bluetooth Headset"; if (acc == 12) return "Gold Headset"; // super rare ~1% if (acc == 13) return "Golden Devil Horns"; // super rare ~1% if (acc == 14) return "Golden Bull Horns"; // super rare ~1% if (acc == 15) return "Blue Boom Headset"; // 16 Balding Cap / 17 Top Hat — rejected if (acc == 18) return "Gold Rims"; // ~1% if (acc == 19) return "Banded Frameless"; // OG rimless + bands into hair // 20 Black Monocle — declined / unused if (acc == 21) return "Gold Banded Frameless"; // ~1% super rare return "None"; } function tieName(uint8 tie) internal pure returns (string memory) { if (tie == 0) return "Blue"; if (tie == 1) return "Green"; if (tie == 2) return "Red"; if (tie == 3) return "Gold"; if (tie == 4) return "Purple"; return "Teal"; } function brokerBadgeName(uint8 badge) internal pure returns (string memory) { if (badge == 0) return "None"; if (badge == 1) return "Insider"; if (badge == 2) return "Whale"; return "Diamond Hands"; } function pocketSquareName(uint8 sq) internal pure returns (string memory) { if (sq == 0) return "None"; if (sq == 1) return "Cream"; if (sq == 2) return "White"; return "Gold"; } function noseColorName(uint8 nose) internal pure returns (string memory) { if (nose == 0) return "Taupe - Flat"; if (nose == 1) return "Taupe - Wide"; // original #ba9a95 shape if (nose == 2) return "Light Brown - Flat"; if (nose == 3) return "Light Brown - Wide"; if (nose == 4) return "Brown - Flat"; if (nose == 5) return "Brown - Wide"; if (nose == 6) return "Dark Brown - Flat"; if (nose == 7) return "Dark Brown - Wide"; if (nose == 8) return "Pink - Flat"; if (nose == 9) return "Pink - Wide"; if (nose == 10) return "Clown Red - Wide"; // ~1% super rare, Wide-only return "None"; // 11 — fairly uncommon (~10%), no nose pixels } function neckwearName(uint8 neckwear) internal pure returns (string memory) { return neckwear == 1 ? "Bow Tie" : "Tie"; } function mouthName(uint8 mouth) internal pure returns (string memory) { if (mouth == 0) return "Neutral"; if (mouth == 1) return "Smirk"; if (mouth == 2) return "Smile"; if (mouth == 3) return "Beard"; if (mouth == 4) return "Open"; if (mouth == 5) return "Mustache"; // chevron if (mouth == 6) return "Blond Beard"; // rare: black top + blonde chinstrap if (mouth == 7) return "Blonde Mustache"; // rare blonde chevron if (mouth == 8) return "Gray Beard"; // rare: black top + gray chinstrap return "Gold Tooth"; // 9 — super rare Smirk + one gold tooth pixel } function suitName(uint8 suit) internal pure returns (string memory) { if (suit == 0) return "Charcoal"; if (suit == 1) return "Navy"; if (suit == 2) return "Slate"; if (suit == 3) return "Steel"; if (suit == 4) return "Purple"; if (suit == 5) return "Forest"; if (suit == 6) return "Rainbow"; // super rare if (suit == 7) return "Pink"; // ultra rare if (suit == 8) return "Red"; // solid crimson ~1% rare return "Red"; // 9 unused (strips rejected) — keep name safe } }

lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol) pragma solidity >=0.4.16; /** * @dev Interface of the ERC-20 standard as defined in the ERC. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets a `value` amount of tokens as the allowance of `spender` over the * caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 value) external returns (bool); }

lib/openzeppelin-contracts/contracts/proxy/Clones.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (proxy/Clones.sol) pragma solidity ^0.8.20; import {Create2} from "../utils/Create2.sol"; import {Errors} from "../utils/Errors.sol"; /** * @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for * deploying minimal proxy contracts, also known as "clones". * * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies * > a minimal bytecode implementation that delegates all calls to a known, fixed address. * * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2` * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the * deterministic method. */ library Clones { error CloneArgumentsTooLong(); /** * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`. * * This function uses the create opcode, which should never revert. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. */ function clone(address implementation) internal returns (address instance) { return clone(implementation, 0); } /** * @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency * to the new contract. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. * * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory) * to always have enough balance for new deployments. Consider exposing this function under a payable method. */ function clone(address implementation, uint256 value) internal returns (address instance) { if (address(this).balance < value) { revert Errors.InsufficientBalance(address(this).balance, value); } assembly ("memory-safe") { // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes // of the `implementation` address with the bytecode before the address. mstore(0x00, or(shr(232, shl(96, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000)) // Packs the remaining 17 bytes of `implementation` with the bytecode after the address. mstore(0x20, or(shl(120, implementation), 0x5af43d82803e903d91602b57fd5bf3)) instance := create(value, 0x09, 0x37) } if (instance == address(0)) { revert Errors.FailedDeployment(); } } /** * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple times will revert, since * the clones cannot be deployed twice at the same address. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. */ function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { return cloneDeterministic(implementation, salt, 0); } /** * @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with * a `value` parameter to send native currency to the new contract. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. * * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory) * to always have enough balance for new deployments. Consider exposing this function under a payable method. */ function cloneDeterministic( address implementation, bytes32 salt, uint256 value ) internal returns (address instance) { if (address(this).balance < value) { revert Errors.InsufficientBalance(address(this).balance, value); } assembly ("memory-safe") { // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes // of the `implementation` address with the bytecode before the address. mstore(0x00, or(shr(232, shl(96, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000)) // Packs the remaining 17 bytes of `implementation` with the bytecode after the address. mstore(0x20, or(shl(120, implementation), 0x5af43d82803e903d91602b57fd5bf3)) instance := create2(value, 0x09, 0x37, salt) } if (instance == address(0)) { revert Errors.FailedDeployment(); } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt, address deployer ) internal pure returns (address predicted) { assembly ("memory-safe") { let ptr := mload(0x40) mstore(add(ptr, 0x38), deployer) mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff) mstore(add(ptr, 0x14), implementation) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73) mstore(add(ptr, 0x58), salt) mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37)) predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt ) internal view returns (address predicted) { return predictDeterministicAddress(implementation, salt, address(this)); } /** * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom * immutable arguments. These are provided through `args` and cannot be changed after deployment. To * access the arguments within the implementation, use {fetchCloneArgs}. * * This function uses the create opcode, which should never revert. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. */ function cloneWithImmutableArgs(address implementation, bytes memory args) internal returns (address instance) { return cloneWithImmutableArgs(implementation, args, 0); } /** * @dev Same as {xref-Clones-cloneWithImmutableArgs-address-bytes-}[cloneWithImmutableArgs], but with a `value` * parameter to send native currency to the new contract. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. * * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory) * to always have enough balance for new deployments. Consider exposing this function under a payable method. */ function cloneWithImmutableArgs( address implementation, bytes memory args, uint256 value ) internal returns (address instance) { if (address(this).balance < value) { revert Errors.InsufficientBalance(address(this).balance, value); } bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args); assembly ("memory-safe") { instance := create(value, add(bytecode, 0x20), mload(bytecode)) } if (instance == address(0)) { revert Errors.FailedDeployment(); } } /** * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom * immutable arguments. These are provided through `args` and cannot be changed after deployment. To * access the arguments within the implementation, use {fetchCloneArgs}. * * This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same * `implementation`, `args` and `salt` multiple times will revert, since the clones cannot be deployed twice * at the same address. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. */ function cloneDeterministicWithImmutableArgs( address implementation, bytes memory args, bytes32 salt ) internal returns (address instance) { return cloneDeterministicWithImmutableArgs(implementation, args, salt, 0); } /** * @dev Same as {xref-Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-}[cloneDeterministicWithImmutableArgs], * but with a `value` parameter to send native currency to the new contract. * * WARNING: This function does not check if `implementation` has code. A clone that points to an address * without code cannot be initialized. Initialization calls may appear to be successful when, in reality, they * have no effect and leave the clone uninitialized, allowing a third party to initialize it later. * * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory) * to always have enough balance for new deployments. Consider exposing this function under a payable method. */ function cloneDeterministicWithImmutableArgs( address implementation, bytes memory args, bytes32 salt, uint256 value ) internal returns (address instance) { bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args); return Create2.deploy(value, salt, bytecode); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}. */ function predictDeterministicAddressWithImmutableArgs( address implementation, bytes memory args, bytes32 salt, address deployer ) internal pure returns (address predicted) { bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args); return Create2.computeAddress(salt, keccak256(bytecode), deployer); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}. */ function predictDeterministicAddressWithImmutableArgs( address implementation, bytes memory args, bytes32 salt ) internal view returns (address predicted) { return predictDeterministicAddressWithImmutableArgs(implementation, args, salt, address(this)); } /** * @dev Get the immutable args attached to a clone. * * - If `instance` is a clone that was deployed using `clone` or `cloneDeterministic`, this * function will return an empty array. * - If `instance` is a clone that was deployed using `cloneWithImmutableArgs` or * `cloneDeterministicWithImmutableArgs`, this function will return the args array used at * creation. * - If `instance` is NOT a clone deployed using this library, the behavior is undefined. This * function should only be used to check addresses that are known to be clones. */ function fetchCloneArgs(address instance) internal view returns (bytes memory) { bytes memory result = new bytes(instance.code.length - 0x2d); // revert if length is too short assembly ("memory-safe") { extcodecopy(instance, add(result, 0x20), 0x2d, mload(result)) } return result; } /** * @dev Helper that prepares the initcode of the proxy with immutable args. * * An assembly variant of this function requires copying the `args` array, which can be efficiently done using * `mcopy`. Unfortunately, that opcode is not available before cancun. A pure solidity implementation using * abi.encodePacked is more expensive but also more portable and easier to review. * * NOTE: https://eips.ethereum.org/EIPS/eip-170[EIP-170] limits the length of the contract code to 24576 bytes. * With the proxy code taking 45 bytes, that limits the length of the immutable args to 24531 bytes. */ function _cloneCodeWithImmutableArgs( address implementation, bytes memory args ) private pure returns (bytes memory) { if (args.length > 0x5fd3) revert CloneArgumentsTooLong(); return abi.encodePacked( hex"61", uint16(args.length + 0x2d), hex"3d81600a3d39f3363d3d373d3d3d363d73", implementation, hex"5af43d82803e903d91602b57fd5bf3", args ); } }

lib/openzeppelin-contracts/contracts/token/common/ERC2981.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.4.0) (token/common/ERC2981.sol) pragma solidity ^0.8.20; import {IERC2981} from "../../interfaces/IERC2981.sol"; import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the ERC. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. */ abstract contract ERC2981 is IERC2981, ERC165 { struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 tokenId => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev The default royalty set is invalid (eg. (numerator / denominator) >= 1). */ error ERC2981InvalidDefaultRoyalty(uint256 numerator, uint256 denominator); /** * @dev The default royalty receiver is invalid. */ error ERC2981InvalidDefaultRoyaltyReceiver(address receiver); /** * @dev The royalty set for a specific `tokenId` is invalid (eg. (numerator / denominator) >= 1). */ error ERC2981InvalidTokenRoyalty(uint256 tokenId, uint256 numerator, uint256 denominator); /** * @dev The royalty receiver for `tokenId` is invalid. */ error ERC2981InvalidTokenRoyaltyReceiver(uint256 tokenId, address receiver); /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /// @inheritdoc IERC2981 function royaltyInfo( uint256 tokenId, uint256 salePrice ) public view virtual returns (address receiver, uint256 amount) { RoyaltyInfo storage _royaltyInfo = _tokenRoyaltyInfo[tokenId]; address royaltyReceiver = _royaltyInfo.receiver; uint96 royaltyFraction = _royaltyInfo.royaltyFraction; if (royaltyReceiver == address(0)) { royaltyReceiver = _defaultRoyaltyInfo.receiver; royaltyFraction = _defaultRoyaltyInfo.royaltyFraction; } uint256 royaltyAmount = (salePrice * royaltyFraction) / _feeDenominator(); return (royaltyReceiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { uint256 denominator = _feeDenominator(); if (feeNumerator > denominator) { // Royalty fee will exceed the sale price revert ERC2981InvalidDefaultRoyalty(feeNumerator, denominator); } if (receiver == address(0)) { revert ERC2981InvalidDefaultRoyaltyReceiver(address(0)); } _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual { uint256 denominator = _feeDenominator(); if (feeNumerator > denominator) { // Royalty fee will exceed the sale price revert ERC2981InvalidTokenRoyalty(tokenId, feeNumerator, denominator); } if (receiver == address(0)) { revert ERC2981InvalidTokenRoyaltyReceiver(tokenId, address(0)); } _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } }

lib/openzeppelin-contracts/contracts/token/ERC721/ERC721.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.24; import {IERC721} from "./IERC721.sol"; import {IERC721Metadata} from "./extensions/IERC721Metadata.sol"; import {ERC721Utils} from "./utils/ERC721Utils.sol"; import {Context} from "../../utils/Context.sol"; import {Strings} from "../../utils/Strings.sol"; import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol"; import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors { using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; mapping(uint256 tokenId => address) private _owners; mapping(address owner => uint256) private _balances; mapping(uint256 tokenId => address) private _tokenApprovals; mapping(address owner => mapping(address operator => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /// @inheritdoc IERC721 function balanceOf(address owner) public view virtual returns (uint256) { if (owner == address(0)) { revert ERC721InvalidOwner(address(0)); } return _balances[owner]; } /// @inheritdoc IERC721 function ownerOf(uint256 tokenId) public view virtual returns (address) { return _requireOwned(tokenId); } /// @inheritdoc IERC721Metadata function name() public view virtual returns (string memory) { return _name; } /// @inheritdoc IERC721Metadata function symbol() public view virtual returns (string memory) { return _symbol; } /// @inheritdoc IERC721Metadata function tokenURI(uint256 tokenId) public view virtual returns (string memory) { _requireOwned(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /// @inheritdoc IERC721 function approve(address to, uint256 tokenId) public virtual { _approve(to, tokenId, _msgSender()); } /// @inheritdoc IERC721 function getApproved(uint256 tokenId) public view virtual returns (address) { _requireOwned(tokenId); return _getApproved(tokenId); } /// @inheritdoc IERC721 function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /// @inheritdoc IERC721 function isApprovedForAll(address owner, address operator) public view virtual returns (bool) { return _operatorApprovals[owner][operator]; } /// @inheritdoc IERC721 function transferFrom(address from, address to, uint256 tokenId) public virtual { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here. address previousOwner = _update(to, tokenId, _msgSender()); if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /// @inheritdoc IERC721 function safeTransferFrom(address from, address to, uint256 tokenId) public { safeTransferFrom(from, to, tokenId, ""); } /// @inheritdoc IERC721 function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual { transferFrom(from, to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist * * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`. */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted. */ function _getApproved(uint256 tokenId) internal view virtual returns (address) { return _tokenApprovals[tokenId]; } /** * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in * particular (ignoring whether it is owned by `owner`). * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) { return spender != address(0) && (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender); } /** * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner. * Reverts if: * - `spender` does not have approval from `owner` for `tokenId`. * - `spender` does not have approval to manage all of `owner`'s assets. * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual { if (!_isAuthorized(owner, spender, tokenId)) { if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } else { revert ERC721InsufficientApproval(spender, tokenId); } } } /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that * a uint256 would ever overflow from increments when these increments are bounded to uint128 values. * * WARNING: Increasing an account's balance using this function tends to be paired with an override of the * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership * remain consistent with one another. */ function _increaseBalance(address account, uint128 value) internal virtual { unchecked { _balances[account] += value; } } /** * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update. * * The `auth` argument is optional. If the value passed is non 0, then this function will check that * `auth` is either the owner of the token, or approved to operate on the token (by the owner). * * Emits a {Transfer} event. * * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}. */ function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) { address from = _ownerOf(tokenId); // Perform (optional) operator check if (auth != address(0)) { _checkAuthorized(from, auth, tokenId); } // Execute the update if (from != address(0)) { // Clear approval. No need to re-authorize or emit the Approval event _approve(address(0), tokenId, address(0), false); unchecked { _balances[from] -= 1; } } if (to != address(0)) { unchecked { _balances[to] += 1; } } _owners[tokenId] = to; emit Transfer(from, to, tokenId); return from; } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner != address(0)) { revert ERC721InvalidSender(address(0)); } } /** * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual { _mint(to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal { address previousOwner = _update(address(0), tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(tokenId); } } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(tokenId); } else if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients * are aware of the ERC-721 standard to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is like {safeTransferFrom} in the sense that it invokes * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `tokenId` token must exist and be owned by `from`. * - `to` cannot be the zero address. * - `from` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId) internal { _safeTransfer(from, to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual { _transfer(from, to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data); } /** * @dev Approve `to` to operate on `tokenId` * * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is * either the owner of the token, or approved to operate on all tokens held by this owner. * * Emits an {Approval} event. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address to, uint256 tokenId, address auth) internal { _approve(to, tokenId, auth, true); } /** * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not * emitted in the context of transfers. */ function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual { // Avoid reading the owner unless necessary if (emitEvent || auth != address(0)) { address owner = _requireOwned(tokenId); // We do not use _isAuthorized because single-token approvals should not be able to call approve if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) { revert ERC721InvalidApprover(auth); } if (emitEvent) { emit Approval(owner, to, tokenId); } } _tokenApprovals[tokenId] = to; } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Requirements: * - operator can't be the address zero. * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { if (owner == address(0)) { revert ERC721InvalidApprover(address(0)); } if (operator == address(0)) { revert ERC721InvalidOperator(operator); } _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned). * Returns the owner. * * Overrides to ownership logic should be done to {_ownerOf}. */ function _requireOwned(uint256 tokenId) internal view returns (address) { address owner = _ownerOf(tokenId); if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } return owner; } }

lib/openzeppelin-contracts/contracts/utils/Strings.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/Strings.sol) pragma solidity ^0.8.24; import {Math} from "./math/Math.sol"; import {SafeCast} from "./math/SafeCast.sol"; import {SignedMath} from "./math/SignedMath.sol"; import {Bytes} from "./Bytes.sol"; /** * @dev String operations. */ library Strings { using SafeCast for *; bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; uint256 private constant SPECIAL_CHARS_LOOKUP = 0xffffffff | // first 32 bits corresponding to the control characters (U+0000 to U+001F) (1 << 0x22) | // double quote (1 << 0x5c); // backslash /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev The string being parsed contains characters that are not in scope of the given base. */ error StringsInvalidChar(); /** * @dev The string being parsed is not a properly formatted address. */ error StringsInvalidAddressFormat(); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; assembly ("memory-safe") { ptr := add(add(buffer, 0x20), length) } while (true) { ptr--; assembly ("memory-safe") { mstore8(ptr, byte(mod(value, 10), HEX_DIGITS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_DIGITS[localValue & 0xf]; localValue >>= 4; } if (localValue != 0) { revert StringsInsufficientHexLength(value, length); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal * representation, according to EIP-55. */ function toChecksumHexString(address addr) internal pure returns (string memory) { bytes memory buffer = bytes(toHexString(addr)); // hash the hex part of buffer (skip length + 2 bytes, length 40) uint256 hashValue; assembly ("memory-safe") { hashValue := shr(96, keccak256(add(buffer, 0x22), 40)) } for (uint256 i = 41; i > 1; --i) { // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f) if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) { // case shift by xoring with 0x20 buffer[i] ^= 0x20; } hashValue >>= 4; } return string(buffer); } /** * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation. */ function toHexString(bytes memory input) internal pure returns (string memory) { unchecked { bytes memory buffer = new bytes(2 * input.length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 0; i < input.length; ++i) { uint8 v = uint8(input[i]); buffer[2 * i + 2] = HEX_DIGITS[v >> 4]; buffer[2 * i + 3] = HEX_DIGITS[v & 0xf]; } return string(buffer); } } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return Bytes.equal(bytes(a), bytes(b)); } /** * @dev Parse a decimal string and returns the value as a `uint256`. * * Requirements: * - The string must be formatted as `[0-9]*` * - The result must fit into an `uint256` type */ function parseUint(string memory input) internal pure returns (uint256) { return parseUint(input, 0, bytes(input).length); } /** * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: * - The substring must be formatted as `[0-9]*` * - The result must fit into an `uint256` type */ function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) { (bool success, uint256 value) = tryParseUint(input, begin, end); if (!success) revert StringsInvalidChar(); return value; } /** * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character. * * NOTE: This function will revert if the result does not fit in a `uint256`. */ function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) { return _tryParseUintUncheckedBounds(input, 0, bytes(input).length); } /** * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid * character. * * NOTE: This function will revert if the result does not fit in a `uint256`. */ function tryParseUint( string memory input, uint256 begin, uint256 end ) internal pure returns (bool success, uint256 value) { if (end > bytes(input).length || begin > end) return (false, 0); return _tryParseUintUncheckedBounds(input, begin, end); } /** * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseUintUncheckedBounds( string memory input, uint256 begin, uint256 end ) private pure returns (bool success, uint256 value) { bytes memory buffer = bytes(input); uint256 result = 0; for (uint256 i = begin; i < end; ++i) { uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i))); if (chr > 9) return (false, 0); result *= 10; result += chr; } return (true, result); } /** * @dev Parse a decimal string and returns the value as a `int256`. * * Requirements: * - The string must be formatted as `[-+]?[0-9]*` * - The result must fit in an `int256` type. */ function parseInt(string memory input) internal pure returns (int256) { return parseInt(input, 0, bytes(input).length); } /** * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: * - The substring must be formatted as `[-+]?[0-9]*` * - The result must fit in an `int256` type. */ function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) { (bool success, int256 value) = tryParseInt(input, begin, end); if (!success) revert StringsInvalidChar(); return value; } /** * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if * the result does not fit in a `int256`. * * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`. */ function tryParseInt(string memory input) internal pure returns (bool success, int256 value) { return _tryParseIntUncheckedBounds(input, 0, bytes(input).length); } uint256 private constant ABS_MIN_INT256 = 2 ** 255; /** * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid * character or if the result does not fit in a `int256`. * * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`. */ function tryParseInt( string memory input, uint256 begin, uint256 end ) internal pure returns (bool success, int256 value) { if (end > bytes(input).length || begin > end) return (false, 0); return _tryParseIntUncheckedBounds(input, begin, end); } /** * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseIntUncheckedBounds( string memory input, uint256 begin, uint256 end ) private pure returns (bool success, int256 value) { bytes memory buffer = bytes(input); // Check presence of a negative sign. bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty bool positiveSign = sign == bytes1("+"); bool negativeSign = sign == bytes1("-"); uint256 offset = (positiveSign || negativeSign).toUint(); (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end); if (absSuccess && absValue < ABS_MIN_INT256) { return (true, negativeSign ? -int256(absValue) : int256(absValue)); } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) { return (true, type(int256).min); } else return (false, 0); } /** * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a `uint256`. * * Requirements: * - The string must be formatted as `(0x)?[0-9a-fA-F]*` * - The result must fit in an `uint256` type. */ function parseHexUint(string memory input) internal pure returns (uint256) { return parseHexUint(input, 0, bytes(input).length); } /** * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: * - The substring must be formatted as `(0x)?[0-9a-fA-F]*` * - The result must fit in an `uint256` type. */ function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) { (bool success, uint256 value) = tryParseHexUint(input, begin, end); if (!success) revert StringsInvalidChar(); return value; } /** * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character. * * NOTE: This function will revert if the result does not fit in a `uint256`. */ function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) { return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length); } /** * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an * invalid character. * * NOTE: This function will revert if the result does not fit in a `uint256`. */ function tryParseHexUint( string memory input, uint256 begin, uint256 end ) internal pure returns (bool success, uint256 value) { if (end > bytes(input).length || begin > end) return (false, 0); return _tryParseHexUintUncheckedBounds(input, begin, end); } /** * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseHexUintUncheckedBounds( string memory input, uint256 begin, uint256 end ) private pure returns (bool success, uint256 value) { bytes memory buffer = bytes(input); // skip 0x prefix if present bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty uint256 offset = hasPrefix.toUint() * 2; uint256 result = 0; for (uint256 i = begin + offset; i < end; ++i) { uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i))); if (chr > 15) return (false, 0); result *= 16; unchecked { // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check). // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked. result += chr; } } return (true, result); } /** * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an `address`. * * Requirements: * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}` */ function parseAddress(string memory input) internal pure returns (address) { return parseAddress(input, 0, bytes(input).length); } /** * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}` */ function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) { (bool success, address value) = tryParseAddress(input, begin, end); if (!success) revert StringsInvalidAddressFormat(); return value; } /** * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly * formatted address. See {parseAddress-string} requirements. */ function tryParseAddress(string memory input) internal pure returns (bool success, address value) { return tryParseAddress(input, 0, bytes(input).length); } /** * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly * formatted address. See {parseAddress-string-uint256-uint256} requirements. */ function tryParseAddress( string memory input, uint256 begin, uint256 end ) internal pure returns (bool success, address value) { if (end > bytes(input).length || begin > end) return (false, address(0)); bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty uint256 expectedLength = 40 + hasPrefix.toUint() * 2; // check that input is the correct length if (end - begin == expectedLength) { // length guarantees that this does not overflow, and value is at most type(uint160).max (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end); return (s, address(uint160(v))); } else { return (false, address(0)); } } function _tryParseChr(bytes1 chr) private pure returns (uint8) { uint8 value = uint8(chr); // Try to parse `chr`: // - Case 1: [0-9] // - Case 2: [a-f] // - Case 3: [A-F] // - otherwise not supported unchecked { if (value > 47 && value < 58) value -= 48; else if (value > 96 && value < 103) value -= 87; else if (value > 64 && value < 71) value -= 55; else return type(uint8).max; } return value; } /** * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata. * * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped. * * NOTE: This function escapes backslashes (including those in \uXXXX sequences) and the characters in ranges * defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). All control characters in U+0000 * to U+001F are escaped (\b, \t, \n, \f, \r use short form; others use \u00XX). ECMAScript's `JSON.parse` does * recover escaped unicode characters that are not in this range, but other tooling may provide different results. */ function escapeJSON(string memory input) internal pure returns (string memory) { bytes memory buffer = bytes(input); // Put output at the FMP. Memory will be reserved later when we figure out the actual length of the escaped // string. All write are done using _unsafeWriteBytesOffset, which avoid the (expensive) length checks for // each character written. bytes memory output; assembly ("memory-safe") { output := mload(0x40) } uint256 outputLength = 0; for (uint256 i = 0; i < buffer.length; ++i) { uint8 char = uint8(bytes1(_unsafeReadBytesOffset(buffer, i))); if (((SPECIAL_CHARS_LOOKUP & (1 << char)) != 0)) { _unsafeWriteBytesOffset(output, outputLength++, "\\"); if (char == 0x08) _unsafeWriteBytesOffset(output, outputLength++, "b"); else if (char == 0x09) _unsafeWriteBytesOffset(output, outputLength++, "t"); else if (char == 0x0a) _unsafeWriteBytesOffset(output, outputLength++, "n"); else if (char == 0x0c) _unsafeWriteBytesOffset(output, outputLength++, "f"); else if (char == 0x0d) _unsafeWriteBytesOffset(output, outputLength++, "r"); else if (char == 0x5c) _unsafeWriteBytesOffset(output, outputLength++, "\\"); else if (char == 0x22) { // solhint-disable-next-line quotes _unsafeWriteBytesOffset(output, outputLength++, '"'); } else { // U+0000 to U+001F without short form: output \u00XX _unsafeWriteBytesOffset(output, outputLength++, "u"); _unsafeWriteBytesOffset(output, outputLength++, "0"); _unsafeWriteBytesOffset(output, outputLength++, "0"); _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char >> 4]); _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char & 0x0f]); } } else { _unsafeWriteBytesOffset(output, outputLength++, bytes1(char)); } } // write the actual length and reserve memory assembly ("memory-safe") { mstore(output, outputLength) mstore(0x40, add(output, add(outputLength, 0x20))) } return string(output); } /** * @dev Reads a bytes32 from a bytes array without bounds checking. * * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the * assembly block as such would prevent some optimizations. */ function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) { // This is not memory safe in the general case, but all calls to this private function are within bounds. assembly ("memory-safe") { value := mload(add(add(buffer, 0x20), offset)) } } /** * @dev Write a bytes1 to a bytes array without bounds checking. * * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the * assembly block as such would prevent some optimizations. */ function _unsafeWriteBytesOffset(bytes memory buffer, uint256 offset, bytes1 value) private pure { // This is not memory safe in the general case, but all calls to this private function are within bounds. assembly ("memory-safe") { mstore8(add(add(buffer, 0x20), offset), shr(248, value)) } } }

lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.20; import {SafeCast} from "./SafeCast.sol"; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant. * * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone. * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute * one branch when needed, making this function more expensive. */ function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) { unchecked { // branchless ternary works because: // b ^ (a ^ b) == a // b ^ 0 == b return b ^ ((a ^ b) * int256(SafeCast.toUint(condition))); } } /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return ternary(a > b, a, b); } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return ternary(a < b, a, b); } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson. // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift, // taking advantage of the most significant (or "sign" bit) in two's complement representation. // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result, // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative). int256 mask = n >> 255; // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it. return uint256((n + mask) ^ mask); } } }

lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; import {StorageSlot} from "./StorageSlot.sol"; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at, * consider using {ReentrancyGuardTransient} instead. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. * * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced * by the {ReentrancyGuardTransient} variant in v6.0. * * @custom:stateless */ abstract contract ReentrancyGuard { using StorageSlot for bytes32; // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant REENTRANCY_GUARD_STORAGE = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); constructor() { _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } /** * @dev A `view` only version of {nonReentrant}. Use to block view functions * from being called, preventing reading from inconsistent contract state. * * CAUTION: This is a "view" modifier and does not change the reentrancy * status. Use it only on view functions. For payable or non-payable functions, * use the standard {nonReentrant} modifier instead. */ modifier nonReentrantView() { _nonReentrantBeforeView(); _; } function _nonReentrantBeforeView() private view { if (_reentrancyGuardEntered()) { revert ReentrancyGuardReentrantCall(); } } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be NOT_ENTERED _nonReentrantBeforeView(); // Any calls to nonReentrant after this point will fail _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED; } function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) { return REENTRANCY_GUARD_STORAGE; } }

lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.20; /** * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeCast { /** * @dev Value doesn't fit in a uint of `bits` size. */ error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value); /** * @dev An int value doesn't fit in a uint of `bits` size. */ error SafeCastOverflowedIntToUint(int256 value); /** * @dev Value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedIntDowncast(uint8 bits, int256 value); /** * @dev A uint value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedUintToInt(uint256 value); /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits */ function toUint248(uint256 value) internal pure returns (uint248) { if (value > type(uint248).max) { revert SafeCastOverflowedUintDowncast(248, value); } return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits */ function toUint240(uint256 value) internal pure returns (uint240) { if (value > type(uint240).max) { revert SafeCastOverflowedUintDowncast(240, value); } return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits */ function toUint232(uint256 value) internal pure returns (uint232) { if (value > type(uint232).max) { revert SafeCastOverflowedUintDowncast(232, value); } return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { if (value > type(uint224).max) { revert SafeCastOverflowedUintDowncast(224, value); } return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits */ function toUint216(uint256 value) internal pure returns (uint216) { if (value > type(uint216).max) { revert SafeCastOverflowedUintDowncast(216, value); } return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits */ function toUint208(uint256 value) internal pure returns (uint208) { if (value > type(uint208).max) { revert SafeCastOverflowedUintDowncast(208, value); } return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits */ function toUint200(uint256 value) internal pure returns (uint200) { if (value > type(uint200).max) { revert SafeCastOverflowedUintDowncast(200, value); } return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits */ function toUint192(uint256 value) internal pure returns (uint192) { if (value > type(uint192).max) { revert SafeCastOverflowedUintDowncast(192, value); } return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits */ function toUint184(uint256 value) internal pure returns (uint184) { if (value > type(uint184).max) { revert SafeCastOverflowedUintDowncast(184, value); } return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits */ function toUint176(uint256 value) internal pure returns (uint176) { if (value > type(uint176).max) { revert SafeCastOverflowedUintDowncast(176, value); } return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits */ function toUint168(uint256 value) internal pure returns (uint168) { if (value > type(uint168).max) { revert SafeCastOverflowedUintDowncast(168, value); } return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits */ function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) { revert SafeCastOverflowedUintDowncast(160, value); } return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits */ function toUint152(uint256 value) internal pure returns (uint152) { if (value > type(uint152).max) { revert SafeCastOverflowedUintDowncast(152, value); } return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits */ function toUint144(uint256 value) internal pure returns (uint144) { if (value > type(uint144).max) { revert SafeCastOverflowedUintDowncast(144, value); } return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits */ function toUint136(uint256 value) internal pure returns (uint136) { if (value > type(uint136).max) { revert SafeCastOverflowedUintDowncast(136, value); } return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { if (value > type(uint128).max) { revert SafeCastOverflowedUintDowncast(128, value); } return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits */ function toUint120(uint256 value) internal pure returns (uint120) { if (value > type(uint120).max) { revert SafeCastOverflowedUintDowncast(120, value); } return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits */ function toUint112(uint256 value) internal pure returns (uint112) { if (value > type(uint112).max) { revert SafeCastOverflowedUintDowncast(112, value); } return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits */ function toUint104(uint256 value) internal pure returns (uint104) { if (value > type(uint104).max) { revert SafeCastOverflowedUintDowncast(104, value); } return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { if (value > type(uint96).max) { revert SafeCastOverflowedUintDowncast(96, value); } return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits */ function toUint88(uint256 value) internal pure returns (uint88) { if (value > type(uint88).max) { revert SafeCastOverflowedUintDowncast(88, value); } return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits */ function toUint80(uint256 value) internal pure returns (uint80) { if (value > type(uint80).max) { revert SafeCastOverflowedUintDowncast(80, value); } return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { if (value > type(uint72).max) { revert SafeCastOverflowedUintDowncast(72, value); } return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { if (value > type(uint64).max) { revert SafeCastOverflowedUintDowncast(64, value); } return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits */ function toUint56(uint256 value) internal pure returns (uint56) { if (value > type(uint56).max) { revert SafeCastOverflowedUintDowncast(56, value); } return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits */ function toUint48(uint256 value) internal pure returns (uint48) { if (value > type(uint48).max) { revert SafeCastOverflowedUintDowncast(48, value); } return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits */ function toUint40(uint256 value) internal pure returns (uint40) { if (value > type(uint40).max) { revert SafeCastOverflowedUintDowncast(40, value); } return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { if (value > type(uint32).max) { revert SafeCastOverflowedUintDowncast(32, value); } return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits */ function toUint24(uint256 value) internal pure returns (uint24) { if (value > type(uint24).max) { revert SafeCastOverflowedUintDowncast(24, value); } return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { if (value > type(uint16).max) { revert SafeCastOverflowedUintDowncast(16, value); } return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits */ function toUint8(uint256 value) internal pure returns (uint8) { if (value > type(uint8).max) { revert SafeCastOverflowedUintDowncast(8, value); } return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { if (value < 0) { revert SafeCastOverflowedIntToUint(value); } return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(248, value); } } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(240, value); } } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(232, value); } } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(224, value); } } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(216, value); } } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(208, value); } } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(200, value); } } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(192, value); } } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(184, value); } } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(176, value); } } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(168, value); } } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(160, value); } } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(152, value); } } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(144, value); } } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(136, value); } } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(128, value); } } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(120, value); } } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(112, value); } } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(104, value); } } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(96, value); } } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(88, value); } } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(80, value); } } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(72, value); } } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(64, value); } } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(56, value); } } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(48, value); } } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(40, value); } } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(32, value); } } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(24, value); } } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(16, value); } } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(8, value); } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive if (value > uint256(type(int256).max)) { revert SafeCastOverflowedUintToInt(value); } return int256(value); } /** * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump. */ function toUint(bool b) internal pure returns (uint256 u) { assembly ("memory-safe") { u := iszero(iszero(b)) } } }

lib/openzeppelin-contracts/contracts/access/Ownable.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; import {Context} from "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }

lib/openzeppelin-contracts/contracts/utils/Bytes.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/Bytes.sol) pragma solidity ^0.8.24; import {Math} from "./math/Math.sol"; /** * @dev Bytes operations. */ library Bytes { /** * @dev Forward search for `s` in `buffer` * * If `s` is present in the buffer, returns the index of the first instance * * If `s` is not present in the buffer, returns type(uint256).max * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`] */ function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) { return indexOf(buffer, s, 0); } /** * @dev Forward search for `s` in `buffer` starting at position `pos` * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`] */ function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) { uint256 length = buffer.length; for (uint256 i = pos; i < length; ++i) { if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) { return i; } } return type(uint256).max; } /** * @dev Backward search for `s` in `buffer` * * If `s` is present in the buffer, returns the index of the last instance * * If `s` is not present in the buffer, returns type(uint256).max * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`] */ function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) { return lastIndexOf(buffer, s, type(uint256).max); } /** * @dev Backward search for `s` in `buffer` starting at position `pos` * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`] */ function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) { unchecked { uint256 length = buffer.length; for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) { if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) { return i - 1; } } return type(uint256).max; } } /** * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in * memory. * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`] */ function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) { return slice(buffer, start, buffer.length); } /** * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in * memory. The `end` argument is truncated to the length of the `buffer`. * * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`] */ function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) { // sanitize end = Math.min(end, buffer.length); start = Math.min(start, end); // allocate and copy bytes memory result = new bytes(end - start); assembly ("memory-safe") { mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start)) } return result; } /** * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer, * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:]. * * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead */ function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) { return splice(buffer, start, buffer.length); } /** * @dev Moves the content of `buffer`, from `start` (included) to `end` (excluded) to the start of that buffer, * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:end]. * The `end` argument is truncated to the length of the `buffer`. * * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead */ function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) { // sanitize end = Math.min(end, buffer.length); start = Math.min(start, end); // move and resize assembly ("memory-safe") { mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start)) mstore(buffer, sub(end, start)) } return buffer; } /** * @dev Replaces bytes in `buffer` starting at `pos` with all bytes from `replacement`. * * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`). * If `pos >= buffer.length`, no replacement occurs and the buffer is returned unchanged. * * NOTE: This function modifies the provided buffer in place. */ function replace(bytes memory buffer, uint256 pos, bytes memory replacement) internal pure returns (bytes memory) { return replace(buffer, pos, replacement, 0, replacement.length); } /** * @dev Replaces bytes in `buffer` starting at `pos` with bytes from `replacement` starting at `offset`. * Copies at most `length` bytes from `replacement` to `buffer`. * * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`, `offset` is * clamped to `[0, replacement.length]`, and `length` is clamped to `min(length, replacement.length - offset, * buffer.length - pos))`. If `pos >= buffer.length` or `offset >= replacement.length`, no replacement occurs * and the buffer is returned unchanged. * * NOTE: This function modifies the provided buffer in place. */ function replace( bytes memory buffer, uint256 pos, bytes memory replacement, uint256 offset, uint256 length ) internal pure returns (bytes memory) { // sanitize pos = Math.min(pos, buffer.length); offset = Math.min(offset, replacement.length); length = Math.min(length, Math.min(replacement.length - offset, buffer.length - pos)); // replace assembly ("memory-safe") { mcopy(add(add(buffer, 0x20), pos), add(add(replacement, 0x20), offset), length) } return buffer; } /** * @dev Concatenate an array of bytes into a single bytes object. * * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent) * `abi.encodePacked`. * * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach. */ function concat(bytes[] memory buffers) internal pure returns (bytes memory) { uint256 length = 0; for (uint256 i = 0; i < buffers.length; ++i) { length += buffers[i].length; } bytes memory result = new bytes(length); uint256 offset = 0x20; for (uint256 i = 0; i < buffers.length; ++i) { bytes memory input = buffers[i]; assembly ("memory-safe") { mcopy(add(result, offset), add(input, 0x20), mload(input)) } unchecked { offset += input.length; } } return result; } /** * @dev Split each byte in `input` into two nibbles (4 bits each) * * Example: hex"01234567" → hex"0001020304050607" */ function toNibbles(bytes memory input) internal pure returns (bytes memory output) { assembly ("memory-safe") { let length := mload(input) output := mload(0x40) mstore(0x40, add(add(output, 0x20), mul(length, 2))) mstore(output, mul(length, 2)) for { let i := 0 } lt(i, length) { i := add(i, 0x10) } { let chunk := shr(128, mload(add(add(input, 0x20), i))) chunk := and( 0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff, or(shl(64, chunk), chunk) ) chunk := and( 0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff, or(shl(32, chunk), chunk) ) chunk := and( 0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff, or(shl(16, chunk), chunk) ) chunk := and( 0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff, or(shl(8, chunk), chunk) ) chunk := and( 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f, or(shl(4, chunk), chunk) ) mstore(add(add(output, 0x20), mul(i, 2)), chunk) } } } /** * @dev Returns true if the two byte buffers are equal. */ function equal(bytes memory a, bytes memory b) internal pure returns (bool) { return a.length == b.length && keccak256(a) == keccak256(b); } /** * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian. * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel] */ function reverseBytes32(bytes32 value) internal pure returns (bytes32) { value = // swap bytes ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) | ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8); value = // swap 2-byte long pairs ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) | ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16); value = // swap 4-byte long pairs ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) | ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32); value = // swap 8-byte long pairs ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) | ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64); return (value >> 128) | (value << 128); // swap 16-byte long pairs } /// @dev Same as {reverseBytes32} but optimized for 128-bit values. function reverseBytes16(bytes16 value) internal pure returns (bytes16) { value = // swap bytes ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8); value = // swap 2-byte long pairs ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16); value = // swap 4-byte long pairs ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) | ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32); return (value >> 64) | (value << 64); // swap 8-byte long pairs } /// @dev Same as {reverseBytes32} but optimized for 64-bit values. function reverseBytes8(bytes8 value) internal pure returns (bytes8) { value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs return (value >> 32) | (value << 32); // swap 4-byte long pairs } /// @dev Same as {reverseBytes32} but optimized for 32-bit values. function reverseBytes4(bytes4 value) internal pure returns (bytes4) { value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes return (value >> 16) | (value << 16); // swap 2-byte long pairs } /// @dev Same as {reverseBytes32} but optimized for 16-bit values. function reverseBytes2(bytes2 value) internal pure returns (bytes2) { return (value >> 8) | (value << 8); } /** * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length` * if the buffer is all zeros. */ function clz(bytes memory buffer) internal pure returns (uint256) { for (uint256 i = 0; i < buffer.length; i += 0x20) { bytes32 chunk = _unsafeReadBytesOffset(buffer, i); if (chunk != bytes32(0)) { return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length); } } return 8 * buffer.length; } /** * @dev Reads a bytes32 from a bytes array without bounds checking. * * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the * assembly block as such would prevent some optimizations. */ function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) { // This is not memory safe in the general case, but all calls to this private function are within bounds. assembly ("memory-safe") { value := mload(add(add(buffer, 0x20), offset)) } } }

lib/openzeppelin-contracts/contracts/token/ERC721/IERC721.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721.sol) pragma solidity >=0.6.2; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC-721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC-721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or * {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the address zero. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }

lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC-1967 implementation slot: * ```solidity * contract ERC1967 { * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot. * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * TIP: Consider using this library along with {SlotDerivation}. */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct Int256Slot { int256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Int256Slot` with member `value` located at `slot`. */ function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } /** * @dev Returns a `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } }

lib/openzeppelin-contracts/contracts/utils/Base64.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/Base64.sol) pragma solidity ^0.8.20; import {SafeCast} from "./math/SafeCast.sol"; /** * @dev Provides a set of functions to operate with Base64 strings. */ library Base64 { using SafeCast for bool; error InvalidBase64Char(bytes1); /** * @dev Converts a `bytes` to its Base64 `string` representation. */ function encode(bytes memory data) internal pure returns (string memory) { return string(_encode(data, false)); } /** * @dev Converts a `bytes` to its Base64Url `string` representation. * Output is not padded with `=` as specified in https://www.rfc-editor.org/rfc/rfc4648[rfc4648]. */ function encodeURL(bytes memory data) internal pure returns (string memory) { return string(_encode(data, true)); } /** * @dev Converts a Base64 `string` to the `bytes` it represents. * * * Supports padded and unpadded inputs. * * Supports both encoding ({encode} and {encodeURL}) seamlessly. * * Reverts with {InvalidBase64Char} if the input contains an invalid character. */ function decode(string memory data) internal pure returns (bytes memory) { return _decode(bytes(data)); } /** * @dev Internal table-agnostic encoding * * Padding is enabled when using the Base64 table, and disabled when using the Base64Url table. * See sections 4 and 5 of https://datatracker.ietf.org/doc/html/rfc4648 */ function _encode(bytes memory data, bool urlAndFilenameSafe) private pure returns (bytes memory result) { /** * Inspired by Brecht Devos (Brechtpd) implementation - MIT license * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol */ if (data.length == 0) return ""; // Padding is enabled by default, but disabled when the "urlAndFilenameSafe" alphabet is used // // If padding is enabled, the final length should be `bytes` data length divided by 3 rounded up and then // multiplied by 4 so that it leaves room for padding the last chunk // - `data.length + 2` -> Prepare for division rounding up // - `/ 3` -> Number of 3-bytes chunks (rounded up) // - `4 *` -> 4 characters for each chunk // This is equivalent to: 4 * Math.ceil(data.length / 3) // // If padding is disabled, the final length should be `bytes` data length multiplied by 4/3 rounded up as // opposed to when padding is required to fill the last chunk. // - `4 * data.length` -> 4 characters for each chunk // - ` + 2` -> Prepare for division rounding up // - `/ 3` -> Number of 3-bytes chunks (rounded up) // This is equivalent to: Math.ceil((4 * data.length) / 3) uint256 resultLength = urlAndFilenameSafe ? (4 * data.length + 2) / 3 : 4 * ((data.length + 2) / 3); assembly ("memory-safe") { result := mload(0x40) // Store the encoding table in the scratch space (and fmp ptr) to avoid memory allocation // // Base64 (ascii) A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 + / // Base64 (hex) 4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435363738392b2f // Base64Url (ascii) A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 - _ // Base64Url (hex) 4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435363738392d5f // xor (hex) 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000670 mstore(0x1f, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef") mstore(0x3f, xor("ghijklmnopqrstuvwxyz0123456789+/", mul(urlAndFilenameSafe, 0x670))) // Prepare result pointer, jump over length let resultPtr := add(result, 0x20) let resultEnd := add(resultPtr, resultLength) let dataPtr := data let endPtr := add(data, mload(data)) // In some cases, the last iteration will read bytes after the end of the data. We cache the value, and // set it to zero to make sure no dirty bytes are read in that section. let afterPtr := add(endPtr, 0x20) let afterCache := mload(afterPtr) mstore(afterPtr, 0x00) // Run over the input, 3 bytes at a time for {} lt(dataPtr, endPtr) {} { // Advance 3 bytes dataPtr := add(dataPtr, 3) let input := mload(dataPtr) // To write each character, shift the 3 byte (24 bits) chunk // 4 times in blocks of 6 bits for each character (18, 12, 6, 0) // and apply logical AND with 0x3F to bitmask the least significant 6 bits. // Use this as an index into the lookup table, mload an entire word // so the desired character is in the least significant byte, and // mstore8 this least significant byte into the result and continue. mstore8(resultPtr, mload(and(shr(18, input), 0x3F))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(and(shr(12, input), 0x3F))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(and(shr(6, input), 0x3F))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(and(input, 0x3F))) resultPtr := add(resultPtr, 1) // Advance } // Reset the value that was cached mstore(afterPtr, afterCache) if iszero(urlAndFilenameSafe) { // When data `bytes` is not exactly 3 bytes long // it is padded with `=` characters at the end switch mod(mload(data), 3) case 1 { mstore8(sub(resultPtr, 1), 0x3d) mstore8(sub(resultPtr, 2), 0x3d) } case 2 { mstore8(sub(resultPtr, 1), 0x3d) } } // Store result length and update FMP to reserve allocated space mstore(result, resultLength) mstore(0x40, resultEnd) } } /** * @dev Internal decoding */ function _decode(bytes memory data) private pure returns (bytes memory result) { bytes4 errorSelector = InvalidBase64Char.selector; uint256 dataLength = data.length; if (dataLength == 0) return ""; uint256 resultLength = (dataLength / 4) * 3; if (dataLength % 4 == 0) { resultLength -= (data[dataLength - 1] == "=").toUint() + (data[dataLength - 2] == "=").toUint(); } else { resultLength += (dataLength % 4) - 1; } assembly ("memory-safe") { result := mload(0x40) // Temporarily store the reverse lookup table between in memory. This spans from 0x00 to 0x50, Using: // - all 64bytes of scratch space // - part of the FMP (at location 0x40) mstore(0x30, 0x2425262728292a2b2c2d2e2f30313233) mstore(0x20, 0x0a0b0c0d0e0f10111213141516171819ffffffff3fff1a1b1c1d1e1f20212223) mstore(0x00, 0x3eff3eff3f3435363738393a3b3c3dffffff00ffffff00010203040506070809) // Prepare result pointer, jump over length let dataPtr := data let resultPtr := add(result, 0x20) let endPtr := add(resultPtr, resultLength) // In some cases, the last iteration will read bytes after the end of the data. We cache the value, and // set it to "==" (fake padding) to make sure no dirty bytes are read in that section. let afterPtr := add(add(data, 0x20), dataLength) let afterCache := mload(afterPtr) mstore(afterPtr, shl(240, 0x3d3d)) // loop while not everything is decoded for {} lt(resultPtr, endPtr) {} { dataPtr := add(dataPtr, 4) // Read a 4 bytes chunk of data let input := mload(dataPtr) // Decode each byte in the chunk as a 6 bit block, and align them to form a block of 3 bytes let a := sub(byte(28, input), 43) // slither-disable-next-line incorrect-shift if iszero(and(shl(a, 1), 0xffffffd0ffffffc47ff5)) { mstore(0, errorSelector) mstore(4, shl(248, add(a, 43))) revert(0, 0x24) } let b := sub(byte(29, input), 43) // slither-disable-next-line incorrect-shift if iszero(and(shl(b, 1), 0xffffffd0ffffffc47ff5)) { mstore(0, errorSelector) mstore(4, shl(248, add(b, 43))) revert(0, 0x24) } let c := sub(byte(30, input), 43) // slither-disable-next-line incorrect-shift if iszero(and(shl(c, 1), 0xffffffd0ffffffc47ff5)) { mstore(0, errorSelector) mstore(4, shl(248, add(c, 43))) revert(0, 0x24) } let d := sub(byte(31, input), 43) // slither-disable-next-line incorrect-shift if iszero(and(shl(d, 1), 0xffffffd0ffffffc47ff5)) { mstore(0, errorSelector) mstore(4, shl(248, add(d, 43))) revert(0, 0x24) } mstore( resultPtr, or( or(shl(250, byte(0, mload(a))), shl(244, byte(0, mload(b)))), or(shl(238, byte(0, mload(c))), shl(232, byte(0, mload(d)))) ) ) resultPtr := add(resultPtr, 3) } // Reset the value that was cached mstore(afterPtr, afterCache) // Store result length and update FMP to reserve allocated space mstore(result, resultLength) mstore(0x40, endPtr) } } }

lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol) pragma solidity >=0.8.4; /** * @dev Standard ERC-20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC-721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC-1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); }

lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.6.0) (utils/LowLevelCall.sol) pragma solidity ^0.8.20; /** * @dev Library of low level call functions that implement different calling strategies to deal with the return data. * * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended * to use the {Address} library instead. */ library LowLevelCall { /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data. function callNoReturn(address target, bytes memory data) internal returns (bool success) { return callNoReturn(target, 0, data); } /// @dev Same as {callNoReturn-address-bytes}, but allows specifying the value to be sent in the call. function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) { assembly ("memory-safe") { success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function callReturn64Bytes( address target, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { return callReturn64Bytes(target, 0, data); } /// @dev Same as {callReturn64Bytes-address-bytes}, but allows specifying the value to be sent in the call. function callReturn64Bytes( address target, uint256 value, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data. function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) { assembly ("memory-safe") { success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function staticcallReturn64Bytes( address target, bytes memory data ) internal view returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data. function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) { assembly ("memory-safe") { success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function delegatecallReturn64Bytes( address target, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Returns the size of the return data buffer. function returnDataSize() internal pure returns (uint256 size) { assembly ("memory-safe") { size := returndatasize() } } /// @dev Returns a buffer containing the return data from the last call. function returnData() internal pure returns (bytes memory result) { assembly ("memory-safe") { result := mload(0x40) mstore(result, returndatasize()) returndatacopy(add(result, 0x20), 0x00, returndatasize()) mstore(0x40, add(result, add(0x20, returndatasize()))) } } /// @dev Revert with the return data from the last call. function bubbleRevert() internal pure { assembly ("memory-safe") { let fmp := mload(0x40) returndatacopy(fmp, 0x00, returndatasize()) revert(fmp, returndatasize()) } } function bubbleRevert(bytes memory returndata) internal pure { assembly ("memory-safe") { revert(add(returndata, 0x20), mload(returndata)) } } }

lib/openzeppelin-contracts/contracts/utils/Create2.sol

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (utils/Create2.sol) pragma solidity ^0.8.20; import {Errors} from "./Errors.sol"; import {LowLevelCall} from "./LowLevelCall.sol"; /** * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer. * `CREATE2` can be used to compute in advance the address where a smart * contract will be deployed, which allows for interesting new mechanisms known * as 'counterfactual interactions'. * * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more * information. */ library Create2 { /** * @dev There's no code to deploy. */ error Create2EmptyBytecode(); /** * @dev Deploys a contract using `CREATE2`. The address where the contract * will be deployed can be known in advance via {computeAddress}. * * The bytecode for a contract can be obtained from Solidity with * `type(contractName).creationCode`. * * Requirements: * * - `bytecode` must not be empty. * - `salt` must have not been used for `bytecode` already. * - the factory must have a balance of at least `amount`. * - if `amount` is non-zero, `bytecode` must have a `payable` constructor. */ function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) { if (address(this).balance < amount) { revert Errors.InsufficientBalance(address(this).balance, amount); } if (bytecode.length == 0) { revert Create2EmptyBytecode(); } assembly ("memory-safe") { addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt) } if (addr == address(0)) { if (LowLevelCall.returnDataSize() == 0) { revert Errors.FailedDeployment(); } else { LowLevelCall.bubbleRevert(); } } } /** * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the * `bytecodeHash` or `salt` will result in a new destination address. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) { return computeAddress(salt, bytecodeHash, address(this)); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) { assembly ("memory-safe") { let ptr := mload(0x40) // Get free memory pointer // | | ↓ ptr ... ↓ ptr + 0x0B (start) ... ↓ ptr + 0x20 ... ↓ ptr + 0x40 ... | // |---------------------|---------------------------------------------------------------------------| // | bytecodeHash | CCCCCCCCCCCCC...CC | // | salt | BBBBBBBBBBBBB...BB | // | deployer | 000000...0000AAAAAAAAAAAAAAAAAAA...AA | // | 0xFF | FF | // |---------------------|---------------------------------------------------------------------------| // | memory | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC | // | keccak(start, 0x55) | ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ | mstore(add(ptr, 0x40), bytecodeHash) mstore(add(ptr, 0x20), salt) mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff mstore8(start, 0xff) addr := and(keccak256(start, 0x55), 0xffffffffffffffffffffffffffffffffffffffff) } } }

0x6080806040526004361015610012575f80fd5b5f905f3560e01c90816301ffc9a7146121395750806304634d8d146120…

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