ERC-721
Overview
Max Total Supply
0 PAGE
Holders
783
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
3 PAGELoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Pages
Compiler Version
v0.8.13+commit.abaa5c0e
Optimization Enabled:
Yes with 1000000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {LibString} from "solmate/utils/LibString.sol"; import {toDaysWadUnsafe} from "solmate/utils/SignedWadMath.sol"; import {LogisticToLinearVRGDA} from "VRGDAs/LogisticToLinearVRGDA.sol"; import {PagesERC721} from "./utils/token/PagesERC721.sol"; import {Goo} from "./Goo.sol"; import {ArtGobblers} from "./ArtGobblers.sol"; /* &@./( &//*& @/*.& (#/./% .,(#%%&@@&%#(/, *#./#, .*(%@@@@&%#((//////(#&@%. #&@&/*./*************.///&@%&@@@@@@@@&%#(///**********./********************#& &@(/*****************************************************************************#/ (&**********************************************************************************@ @**********************************************************************************(& &/*******************************************************************************%@. ,( *&/***********************************************************************./#@@%(((#@% .// (@/***./*****************************************************.///#&@@@&##(((#(##((##%& /*.// *@@&#(/////(#&@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&%%%%%####(#(((((((##(((##((#(###((((#@& (****./ @###(###(((((###(##((#(((((#(#####((((#(((((((#((((((((((((((((((((#(##(####((((#(#@ /******./ &#((#########(############((#(######(########(####(##(###%&&&%########%&&%###((((####@ ,********./ /&((((#(#((##(((#(((#((########(###((((((((((((((((#((%&#((#((#((((((((((#((((((((((((#@ .**********( @#(#(#####(###(#&&&#(((((((((#(((%@%##########(######&#((#&#(((##((((%&@%#((##(#(((#((#%& /**********( /%(#(((((#((#&%(((#(###(#########(((###(((#####(###((#(%@%###(###((((##(((##&%#(##(((##(#@, (**********./ @#(#(((((###((#(#((#(((((###(((#(#%@@###((#####(###((#&%&&/. .*#&&@#((((((((%@ ./**********( ,%((((((((##((((#&@#(##((((((##%%&&&&%%#&##((###(##((%* .@#(##((##@. ./********./ %#((#(((((#####@##(##%@&(. %#((#((###%* *(,. %#((#(((@, /********( @#((#((((####@#%@# .&((((##(& &@@@@@@% &#((#&#&, /******( ,&(#(#((((###@& .&##(###& /@@@@@@ (%((((#@% ./*#@@@@* (%#(((((#((#& #@@@@@&. (%#(#((&. /#. ##(#(#(##@& @%(/((((& &####(((((#@ .@@@@@@@ &((##(#@@(. .#&%#&(#####((##@. /#(((((((## (#* @##(#(((((#@ ,@@@/* @&((####(&&#(##%%&&&%%##%&&&&&%##(((#%%(###((####((&& #((((%@@@@@. @#(((#@*&##(((((((#@ .%&#@#((####(((#((#(((((((((((((((((((##%((#(###((#####(#@ #@/,,,@#((#%( @((&%,,,&&%((((((#(#&, .%@%#((#@%(((###((((#(((##%&&&&&&&&&&&%#((((####(###(###(###((#@% #@##&(,,,(&(##(#@ &###@**#@@@@(((((((##(@@@#, ,(@@&##(((((((((#((((#####((#%@@@@@@@@@@@@@@@@@&&%%################%%(##@& %&##((((#&@@%(((((%# &##(####(#&@&(((((((#(##@#((((((((##((###(#(#(((#%&##(#####(####(##@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%##(((#((%@ *&#((#######((((###(%&@ (#(####(((#&@%(((((####(##%&##(#((((###(###%@@%###(##%%%###(#(####@@@@&%###((##((((((((##((((((((##((((((#((##(#@ (&((((((((((((((((##@&/((@@&####(((((((#&&%#(#((((((((#(((((#((###(#((#&@&&@@@@@@@@%((((((#((((#((((((((((((((((((((((((((((((((((((((((((# .@#(##((((((((((#((&@#%@@&%%&@&##(((###(#####(#@%##(###((#######(((#(#%@#(((#((#(######(###############(###############(###############(##(## (%(#((#((((((((((#&@%#(%%,,,,&#(#@######(####(((((%%(#(#(###(#(((#%@@@@@&##(####(((#(#(#(#######(#######(#######(#######(#######(#######(##((# (%((####((###(#&@########@*,,,@#(#%@(((#((#######(((#&(##(###(%@@@@@%##((#@&%####&@@%(###(###############(###############(###############(###(# @((##(##(((#@%#(#((##(#(#(#&@&#(##@&&@@@&##(#(###(#((&##%&@@%##(#(#(((####((((&%((###((#&####(###(###(###(###(###(###(###(###(###(###(###(####( @((#(((##@%(((((((######((###(#&@%#(#(#(#(##########(%%((((#((((#(((((((((((((#&&#(###&&(((##############(###############(###############(##### .%(#(#%@#((###(#((########&@@((((&#(#####((######(##(%&#((#######(#######(#####(#####((##(#######(#######(#######(#######(#######(#######(##### &##@#(#((##((#####(#&&#(((#&(((@#######(##########(&%%#(#((##(#########(############((((###############(###############(###############(##### *%(((#(#(#(#(#(#%@#(((((((((##(((((((#(#(#(#(#(#(#@###(((#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(# ,&(##(#(#####((%@#(###((((((((####((###(########((%@&##(###############(###############(###############(###############(###############(##### &#((((#(##(####&%(##(((((%@%((#(#######(######(##%@&#((((######(#######(#######(#######(#######(#######(#######(#######(#######(#######(##### %###((#(##########((###((##((##########(####(#((&&###(((###############(###############(###############(###############(###############(##### &#(#(#(###(###(##((###(###((##(###(###(###((#&&#######(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(###(# %%(#(###(#(#(########(#####(#########(###((#&%#(#####(###############(###############(###############(###############(#############(((##### (&%%#%#%#((#(#####(#######(#######(######((#&%(###(#######(#######(#######(#######(#######(#######(#######(#######((##(##((#(#(###(((### ##(#(####(###############(######(((((####(###############(###############(###############(#############(##(#((##%%&@@@@&&&%%%%% &((((((((((((((((((((((((((((((((((((##((((((((((((((((((((((((((((((((((((((((((((((((((((((((##(((##&@@&&%%%%%%%%%%%%%%%%%% &#(((#(###############(#############%&((((############(###############(###############(#######%&@&%%%%%%%%%%%%%%%%%%%%%%%%%% @####(#######(#######(#######(##(%&(((#(#####(#######(#######(#######(#######(#######((##%@&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @#(((###############(#######((#@#(##(###############(###############(##############(%@&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &(#(###(###(###(###(###(##((#&###(((###(###(###(###(###(###(###(###(###(###(#####@&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%((###############(#####((#&######(###############(###############(#(########&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &#(#######(#######(######(%%##((##(#######(#######(#######(#######(####(((#@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @################(######(%%##((##((##############(###############(##(###@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &##((#(#(#(#(#(#(#(#(#(#(@##(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(#(##@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% (%(((###########(#######(#&&##(#(###############(################(#@&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ##(####(#######(#######(#(#%&#((#######(#######(#######(#######(&@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%(((###(#####(########(###(#&%###############(############((#@&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ /// @title Pages NFT /// @author FrankieIsLost <[email protected]> /// @author transmissions11 <[email protected]> /// @notice Pages is an ERC721 that can hold custom art. contract Pages is PagesERC721, LogisticToLinearVRGDA { using LibString for uint256; /*////////////////////////////////////////////////////////////// ADDRESSES //////////////////////////////////////////////////////////////*/ /// @notice The address of the goo ERC20 token contract. Goo public immutable goo; /// @notice The address which receives pages reserved for the community. address public immutable community; /*////////////////////////////////////////////////////////////// URIS //////////////////////////////////////////////////////////////*/ /// @notice Base URI for minted pages. string public BASE_URI; /*////////////////////////////////////////////////////////////// VRGDA INPUT STATE //////////////////////////////////////////////////////////////*/ /// @notice Timestamp for the start of the VRGDA mint. uint256 public immutable mintStart; /// @notice Id of the most recently minted page. /// @dev Will be 0 if no pages have been minted yet. uint128 public currentId; /*////////////////////////////////////////////////////////////// COMMUNITY PAGES STATE //////////////////////////////////////////////////////////////*/ /// @notice The number of pages minted to the community reserve. uint128 public numMintedForCommunity; /*////////////////////////////////////////////////////////////// PRICING CONSTANTS //////////////////////////////////////////////////////////////*/ /// @dev The day the switch from a logistic to translated linear VRGDA is targeted to occur. /// @dev Represented as an 18 decimal fixed point number. int256 internal constant SWITCH_DAY_WAD = 233e18; /// @notice The minimum amount of pages that must be sold for the VRGDA issuance /// schedule to switch from logistic to the "post switch" translated linear formula. /// @dev Computed off-chain by plugging SWITCH_DAY_WAD into the uninverted pacing formula. /// @dev Represented as an 18 decimal fixed point number. int256 internal constant SOLD_BY_SWITCH_WAD = 8336.760939794622713006e18; /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event PagePurchased(address indexed user, uint256 indexed pageId, uint256 price); event CommunityPagesMinted(address indexed user, uint256 lastMintedPageId, uint256 numPages); /*////////////////////////////////////////////////////////////// ERRORS //////////////////////////////////////////////////////////////*/ error ReserveImbalance(); error PriceExceededMax(uint256 currentPrice); /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ /// @notice Sets VRGDA parameters, mint start, relevant addresses, and base URI. /// @param _mintStart Timestamp for the start of the VRGDA mint. /// @param _goo Address of the Goo contract. /// @param _community Address of the community reserve. /// @param _artGobblers Address of the ArtGobblers contract. /// @param _baseUri Base URI for token metadata. constructor( // Mint config: uint256 _mintStart, // Addresses: Goo _goo, address _community, ArtGobblers _artGobblers, // URIs: string memory _baseUri ) PagesERC721(_artGobblers, "Pages", "PAGE") LogisticToLinearVRGDA( 4.2069e18, // Target price. 0.31e18, // Price decay percent. 9000e18, // Logistic asymptote. 0.014e18, // Logistic time scale. SOLD_BY_SWITCH_WAD, // Sold by switch. SWITCH_DAY_WAD, // Target switch day. 9e18 // Pages to target per day. ) { mintStart = _mintStart; goo = _goo; community = _community; BASE_URI = _baseUri; } /*////////////////////////////////////////////////////////////// MINTING LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Mint a page with goo, burning the cost. /// @param maxPrice Maximum price to pay to mint the page. /// @param useVirtualBalance Whether the cost is paid from the /// user's virtual goo balance, or from their ERC20 goo balance. /// @return pageId The id of the page that was minted. function mintFromGoo(uint256 maxPrice, bool useVirtualBalance) external returns (uint256 pageId) { // Will revert if prior to mint start. uint256 currentPrice = pagePrice(); // If the current price is above the user's specified max, revert. if (currentPrice > maxPrice) revert PriceExceededMax(currentPrice); // Decrement the user's goo balance by the current // price, either from virtual balance or ERC20 balance. useVirtualBalance ? artGobblers.burnGooForPages(msg.sender, currentPrice) : goo.burnForPages(msg.sender, currentPrice); unchecked { emit PagePurchased(msg.sender, pageId = ++currentId, currentPrice); _mint(msg.sender, pageId); } } /// @notice Calculate the mint cost of a page. /// @dev If the number of sales is below a pre-defined threshold, we use the /// VRGDA pricing algorithm, otherwise we use the post-switch pricing formula. /// @dev Reverts due to underflow if minting hasn't started yet. Done to save gas. function pagePrice() public view returns (uint256) { // We need checked math here to cause overflow // before minting has begun, preventing mints. uint256 timeSinceStart = block.timestamp - mintStart; unchecked { // The number of pages minted for the community reserve // should never exceed 10% of the total supply of pages. return getVRGDAPrice(toDaysWadUnsafe(timeSinceStart), currentId - numMintedForCommunity); } } /*////////////////////////////////////////////////////////////// COMMUNITY PAGES MINTING LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Mint a number of pages to the community reserve. /// @param numPages The number of pages to mint to the reserve. /// @dev Pages minted to the reserve cannot comprise more than 10% of the sum of the /// supply of goo minted pages and the supply of pages minted to the community reserve. function mintCommunityPages(uint256 numPages) external returns (uint256 lastMintedPageId) { unchecked { // Optimistically increment numMintedForCommunity, may be reverted below. // Overflow in this calculation is possible but numPages would have to be so // large that it would cause the loop in _batchMint to run out of gas quickly. uint256 newNumMintedForCommunity = numMintedForCommunity += uint128(numPages); // Ensure that after this mint pages minted to the community reserve won't comprise more than // 10% of the new total page supply. currentId is equivalent to the current total supply of pages. if (newNumMintedForCommunity > ((lastMintedPageId = currentId) + numPages) / 10) revert ReserveImbalance(); // Mint the pages to the community reserve and update lastMintedPageId once minting is complete. lastMintedPageId = _batchMint(community, numPages, lastMintedPageId); currentId = uint128(lastMintedPageId); // Update currentId with the last minted page id. emit CommunityPagesMinted(msg.sender, lastMintedPageId, numPages); } } /*////////////////////////////////////////////////////////////// TOKEN URI LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Returns a page's URI if it has been minted. /// @param pageId The id of the page to get the URI for. function tokenURI(uint256 pageId) public view virtual override returns (string memory) { if (pageId == 0 || pageId > currentId) revert("NOT_MINTED"); return string.concat(BASE_URI, pageId.toString()); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {unsafeWadDiv} from "solmate/utils/SignedWadMath.sol"; import {VRGDA} from "./VRGDA.sol"; import {LogisticVRGDA} from "./LogisticVRGDA.sol"; /// @title Logistic To Linear Variable Rate Gradual Dutch Auction /// @author transmissions11 <[email protected]> /// @author FrankieIsLost <[email protected]> /// @notice VRGDA with a piecewise logistic and linear issuance curve. abstract contract LogisticToLinearVRGDA is LogisticVRGDA { /*////////////////////////////////////////////////////////////// PRICING PARAMETERS //////////////////////////////////////////////////////////////*/ /// @dev The number of tokens that must be sold for the switch to occur. /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable soldBySwitch; /// @dev The time soldBySwitch tokens were targeted to sell by. /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable switchTime; /// @dev The total number of tokens to target selling every full unit of time. /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable perTimeUnit; /// @notice Sets pricing parameters for the VRGDA. /// @param _targetPrice The target price for a token if sold on pace, scaled by 1e18. /// @param _priceDecayPercent The percent price decays per unit of time with no sales, scaled by 1e18. /// @param _logisticAsymptote The asymptote (minus 1) of the pre-switch logistic curve, scaled by 1e18. /// @param _timeScale The steepness of the pre-switch logistic curve, scaled by 1e18. /// @param _soldBySwitch The number of tokens that must be sold for the switch to occur. /// @param _switchTime The time soldBySwitch tokens were targeted to sell by, scaled by 1e18. /// @param _perTimeUnit The number of tokens to target selling in 1 full unit of time, scaled by 1e18. constructor( int256 _targetPrice, int256 _priceDecayPercent, int256 _logisticAsymptote, int256 _timeScale, int256 _soldBySwitch, int256 _switchTime, int256 _perTimeUnit ) LogisticVRGDA(_targetPrice, _priceDecayPercent, _logisticAsymptote, _timeScale) { soldBySwitch = _soldBySwitch; switchTime = _switchTime; perTimeUnit = _perTimeUnit; } /*////////////////////////////////////////////////////////////// PRICING LOGIC //////////////////////////////////////////////////////////////*/ /// @dev Given a number of tokens sold, return the target time that number of tokens should be sold by. /// @param sold A number of tokens sold, scaled by 1e18, to get the corresponding target sale time for. /// @return The target time the tokens should be sold by, scaled by 1e18, where the time is /// relative, such that 0 means the tokens should be sold immediately when the VRGDA begins. function getTargetSaleTime(int256 sold) public view virtual override returns (int256) { // If we've not yet reached the number of sales required for the switch // to occur, we'll continue using the standard logistic VRGDA schedule. if (sold < soldBySwitch) return LogisticVRGDA.getTargetSaleTime(sold); unchecked { return unsafeWadDiv(sold - soldBySwitch, perTimeUnit) + switchTime; } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {wadLn, unsafeDiv, unsafeWadDiv} from "solmate/utils/SignedWadMath.sol"; import {VRGDA} from "./VRGDA.sol"; /// @title Logistic Variable Rate Gradual Dutch Auction /// @author transmissions11 <[email protected]> /// @author FrankieIsLost <[email protected]> /// @notice VRGDA with a logistic issuance curve. abstract contract LogisticVRGDA is VRGDA { /*////////////////////////////////////////////////////////////// PRICING PARAMETERS //////////////////////////////////////////////////////////////*/ /// @dev The maximum number of tokens of tokens to sell + 1. We add /// 1 because the logistic function will never fully reach its limit. /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable logisticLimit; /// @dev The maximum number of tokens of tokens to sell + 1 multiplied /// by 2. We could compute it on the fly each time but this saves gas. /// @dev Represented as a 36 decimal fixed point number. int256 internal immutable logisticLimitDoubled; /// @dev Time scale controls the steepness of the logistic curve, /// which affects how quickly we will reach the curve's asymptote. /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable timeScale; /// @notice Sets pricing parameters for the VRGDA. /// @param _targetPrice The target price for a token if sold on pace, scaled by 1e18. /// @param _priceDecayPercent The percent price decays per unit of time with no sales, scaled by 1e18. /// @param _maxSellable The maximum number of tokens to sell, scaled by 1e18. /// @param _timeScale The steepness of the logistic curve, scaled by 1e18. constructor( int256 _targetPrice, int256 _priceDecayPercent, int256 _maxSellable, int256 _timeScale ) VRGDA(_targetPrice, _priceDecayPercent) { // Add 1 wad to make the limit inclusive of _maxSellable. logisticLimit = _maxSellable + 1e18; // Scale by 2e18 to both double it and give it 36 decimals. logisticLimitDoubled = logisticLimit * 2e18; timeScale = _timeScale; } /*////////////////////////////////////////////////////////////// PRICING LOGIC //////////////////////////////////////////////////////////////*/ /// @dev Given a number of tokens sold, return the target time that number of tokens should be sold by. /// @param sold A number of tokens sold, scaled by 1e18, to get the corresponding target sale time for. /// @return The target time the tokens should be sold by, scaled by 1e18, where the time is /// relative, such that 0 means the tokens should be sold immediately when the VRGDA begins. function getTargetSaleTime(int256 sold) public view virtual override returns (int256) { unchecked { return -unsafeWadDiv(wadLn(unsafeDiv(logisticLimitDoubled, sold + logisticLimit) - 1e18), timeScale); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {wadExp, wadLn, wadMul, unsafeWadMul, toWadUnsafe} from "solmate/utils/SignedWadMath.sol"; /// @title Variable Rate Gradual Dutch Auction /// @author transmissions11 <[email protected]> /// @author FrankieIsLost <[email protected]> /// @notice Sell tokens roughly according to an issuance schedule. abstract contract VRGDA { /*////////////////////////////////////////////////////////////// VRGDA PARAMETERS //////////////////////////////////////////////////////////////*/ /// @notice Target price for a token, to be scaled according to sales pace. /// @dev Represented as an 18 decimal fixed point number. int256 public immutable targetPrice; /// @dev Precomputed constant that allows us to rewrite a pow() as an exp(). /// @dev Represented as an 18 decimal fixed point number. int256 internal immutable decayConstant; /// @notice Sets target price and per time unit price decay for the VRGDA. /// @param _targetPrice The target price for a token if sold on pace, scaled by 1e18. /// @param _priceDecayPercent The percent price decays per unit of time with no sales, scaled by 1e18. constructor(int256 _targetPrice, int256 _priceDecayPercent) { targetPrice = _targetPrice; decayConstant = wadLn(1e18 - _priceDecayPercent); // The decay constant must be negative for VRGDAs to work. require(decayConstant < 0, "NON_NEGATIVE_DECAY_CONSTANT"); } /*////////////////////////////////////////////////////////////// PRICING LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Calculate the price of a token according to the VRGDA formula. /// @param timeSinceStart Time passed since the VRGDA began, scaled by 1e18. /// @param sold The total number of tokens that have been sold so far. /// @return The price of a token according to VRGDA, scaled by 1e18. function getVRGDAPrice(int256 timeSinceStart, uint256 sold) public view virtual returns (uint256) { unchecked { // prettier-ignore return uint256(wadMul(targetPrice, wadExp(unsafeWadMul(decayConstant, // Theoretically calling toWadUnsafe with sold can silently overflow but under // any reasonable circumstance it will never be large enough. We use sold + 1 as // the VRGDA formula's n param represents the nth token and sold is the n-1th token. timeSinceStart - getTargetSaleTime(toWadUnsafe(sold + 1)) )))); } } /// @dev Given a number of tokens sold, return the target time that number of tokens should be sold by. /// @param sold A number of tokens sold, scaled by 1e18, to get the corresponding target sale time for. /// @return The target time the tokens should be sold by, scaled by 1e18, where the time is /// relative, such that 0 means the tokens should be sold immediately when the VRGDA begins. function getTargetSaleTime(int256 sold) public view virtual returns (int256); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol"; /// @title GOO (Gradual Ownership Optimization) Issuance /// @author transmissions11 <[email protected]> /// @author FrankieIsLost <[email protected]> /// @notice Implementation of the GOO Issuance mechanism. library LibGOO { using FixedPointMathLib for uint256; /// @notice Compute goo balance based on emission multiple, last balance, and time elapsed. /// @param emissionMultiple The multiple on emissions to consider when computing the balance. /// @param lastBalanceWad The last checkpointed balance to apply the emission multiple over time to, scaled by 1e18. /// @param timeElapsedWad The time elapsed since the last checkpoint, scaled by 1e18. function computeGOOBalance( uint256 emissionMultiple, uint256 lastBalanceWad, uint256 timeElapsedWad ) internal pure returns (uint256) { unchecked { // We use wad math here because timeElapsedWad is, as the name indicates, a wad. uint256 timeElapsedSquaredWad = timeElapsedWad.mulWadDown(timeElapsedWad); // prettier-ignore return lastBalanceWad + // The last recorded balance. // Don't need to do wad multiplication since we're // multiplying by a plain integer with no decimals. // Shift right by 2 is equivalent to division by 4. ((emissionMultiple * timeElapsedSquaredWad) >> 2) + timeElapsedWad.mulWadDown( // Terms are wads, so must mulWad. // No wad multiplication for emissionMultiple * lastBalance // because emissionMultiple is a plain integer with no decimals. // We multiply the sqrt's radicand by 1e18 because it expects ints. (emissionMultiple * lastBalanceWad * 1e18).sqrt() ); } } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Simple single owner authorization mixin. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol) abstract contract Owned { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event OwnershipTransferred(address indexed user, address indexed newOwner); /*////////////////////////////////////////////////////////////// OWNERSHIP STORAGE //////////////////////////////////////////////////////////////*/ address public owner; modifier onlyOwner() virtual { require(msg.sender == owner, "UNAUTHORIZED"); _; } /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor(address _owner) { owner = _owner; emit OwnershipTransferred(address(0), _owner); } /*////////////////////////////////////////////////////////////// OWNERSHIP LOGIC //////////////////////////////////////////////////////////////*/ function transferOwnership(address newOwner) public virtual onlyOwner { owner = newOwner; emit OwnershipTransferred(msg.sender, newOwner); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Minimalist and gas efficient standard ERC1155 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol) abstract contract ERC1155 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event TransferSingle( address indexed operator, address indexed from, address indexed to, uint256 id, uint256 amount ); event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] amounts ); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); event URI(string value, uint256 indexed id); /*////////////////////////////////////////////////////////////// ERC1155 STORAGE //////////////////////////////////////////////////////////////*/ mapping(address => mapping(uint256 => uint256)) public balanceOf; mapping(address => mapping(address => bool)) public isApprovedForAll; /*////////////////////////////////////////////////////////////// METADATA LOGIC //////////////////////////////////////////////////////////////*/ function uri(uint256 id) public view virtual returns (string memory); /*////////////////////////////////////////////////////////////// ERC1155 LOGIC //////////////////////////////////////////////////////////////*/ function setApprovalForAll(address operator, bool approved) public virtual { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) public virtual { require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED"); balanceOf[from][id] -= amount; balanceOf[to][id] += amount; emit TransferSingle(msg.sender, from, to, id, amount); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) == ERC1155TokenReceiver.onERC1155Received.selector, "UNSAFE_RECIPIENT" ); } function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) public virtual { require(ids.length == amounts.length, "LENGTH_MISMATCH"); require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED"); // Storing these outside the loop saves ~15 gas per iteration. uint256 id; uint256 amount; for (uint256 i = 0; i < ids.length; ) { id = ids[i]; amount = amounts[i]; balanceOf[from][id] -= amount; balanceOf[to][id] += amount; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, from, to, ids, amounts); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) == ERC1155TokenReceiver.onERC1155BatchReceived.selector, "UNSAFE_RECIPIENT" ); } function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) public view virtual returns (uint256[] memory balances) { require(owners.length == ids.length, "LENGTH_MISMATCH"); balances = new uint256[](owners.length); // Unchecked because the only math done is incrementing // the array index counter which cannot possibly overflow. unchecked { for (uint256 i = 0; i < owners.length; ++i) { balances[i] = balanceOf[owners[i]][ids[i]]; } } } /*////////////////////////////////////////////////////////////// ERC165 LOGIC //////////////////////////////////////////////////////////////*/ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165 interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155 interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint( address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { balanceOf[to][id] += amount; emit TransferSingle(msg.sender, address(0), to, id, amount); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) == ERC1155TokenReceiver.onERC1155Received.selector, "UNSAFE_RECIPIENT" ); } function _batchMint( address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { uint256 idsLength = ids.length; // Saves MLOADs. require(idsLength == amounts.length, "LENGTH_MISMATCH"); for (uint256 i = 0; i < idsLength; ) { balanceOf[to][ids[i]] += amounts[i]; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, address(0), to, ids, amounts); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) == ERC1155TokenReceiver.onERC1155BatchReceived.selector, "UNSAFE_RECIPIENT" ); } function _batchBurn( address from, uint256[] memory ids, uint256[] memory amounts ) internal virtual { uint256 idsLength = ids.length; // Saves MLOADs. require(idsLength == amounts.length, "LENGTH_MISMATCH"); for (uint256 i = 0; i < idsLength; ) { balanceOf[from][ids[i]] -= amounts[i]; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, from, address(0), ids, amounts); } function _burn( address from, uint256 id, uint256 amount ) internal virtual { balanceOf[from][id] -= amount; emit TransferSingle(msg.sender, from, address(0), id, amount); } } /// @notice A generic interface for a contract which properly accepts ERC1155 tokens. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol) abstract contract ERC1155TokenReceiver { function onERC1155Received( address, address, uint256, uint256, bytes calldata ) external virtual returns (bytes4) { return ERC1155TokenReceiver.onERC1155Received.selector; } function onERC1155BatchReceived( address, address, uint256[] calldata, uint256[] calldata, bytes calldata ) external virtual returns (bytes4) { return ERC1155TokenReceiver.onERC1155BatchReceived.selector; } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it. abstract contract ERC20 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); /*////////////////////////////////////////////////////////////// METADATA STORAGE //////////////////////////////////////////////////////////////*/ string public name; string public symbol; uint8 public immutable decimals; /*////////////////////////////////////////////////////////////// ERC20 STORAGE //////////////////////////////////////////////////////////////*/ uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; /*////////////////////////////////////////////////////////////// EIP-2612 STORAGE //////////////////////////////////////////////////////////////*/ uint256 internal immutable INITIAL_CHAIN_ID; bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR; mapping(address => uint256) public nonces; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor( string memory _name, string memory _symbol, uint8 _decimals ) { name = _name; symbol = _symbol; decimals = _decimals; INITIAL_CHAIN_ID = block.chainid; INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); } /*////////////////////////////////////////////////////////////// ERC20 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 amount) public virtual returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) public virtual returns (bool) { balanceOf[msg.sender] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(msg.sender, to, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual returns (bool) { uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount; balanceOf[from] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } /*////////////////////////////////////////////////////////////// EIP-2612 LOGIC //////////////////////////////////////////////////////////////*/ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED"); // Unchecked because the only math done is incrementing // the owner's nonce which cannot realistically overflow. unchecked { address recoveredAddress = ecrecover( keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( keccak256( "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" ), owner, spender, value, nonces[owner]++, deadline ) ) ) ), v, r, s ); require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER"); allowance[recoveredAddress][spender] = value; } emit Approval(owner, spender, value); } function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator(); } function computeDomainSeparator() internal view virtual returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256("1"), block.chainid, address(this) ) ); } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; // Cannot underflow because a user's balance // will never be larger than the total supply. unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern, minimalist, and gas efficient ERC-721 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol) abstract contract ERC721 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 indexed id); event Approval(address indexed owner, address indexed spender, uint256 indexed id); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /*////////////////////////////////////////////////////////////// METADATA STORAGE/LOGIC //////////////////////////////////////////////////////////////*/ string public name; string public symbol; function tokenURI(uint256 id) public view virtual returns (string memory); /*////////////////////////////////////////////////////////////// ERC721 BALANCE/OWNER STORAGE //////////////////////////////////////////////////////////////*/ mapping(uint256 => address) internal _ownerOf; mapping(address => uint256) internal _balanceOf; function ownerOf(uint256 id) public view virtual returns (address owner) { require((owner = _ownerOf[id]) != address(0), "NOT_MINTED"); } function balanceOf(address owner) public view virtual returns (uint256) { require(owner != address(0), "ZERO_ADDRESS"); return _balanceOf[owner]; } /*////////////////////////////////////////////////////////////// ERC721 APPROVAL STORAGE //////////////////////////////////////////////////////////////*/ mapping(uint256 => address) public getApproved; mapping(address => mapping(address => bool)) public isApprovedForAll; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor(string memory _name, string memory _symbol) { name = _name; symbol = _symbol; } /*////////////////////////////////////////////////////////////// ERC721 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 id) public virtual { address owner = _ownerOf[id]; require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED"); getApproved[id] = spender; emit Approval(owner, spender, id); } function setApprovalForAll(address operator, bool approved) public virtual { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function transferFrom( address from, address to, uint256 id ) public virtual { require(from == _ownerOf[id], "WRONG_FROM"); require(to != address(0), "INVALID_RECIPIENT"); require( msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id], "NOT_AUTHORIZED" ); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. unchecked { _balanceOf[from]--; _balanceOf[to]++; } _ownerOf[id] = to; delete getApproved[id]; emit Transfer(from, to, id); } function safeTransferFrom( address from, address to, uint256 id ) public virtual { transferFrom(from, to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } function safeTransferFrom( address from, address to, uint256 id, bytes calldata data ) public virtual { transferFrom(from, to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } /*////////////////////////////////////////////////////////////// ERC165 LOGIC //////////////////////////////////////////////////////////////*/ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165 interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721 interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 id) internal virtual { require(to != address(0), "INVALID_RECIPIENT"); require(_ownerOf[id] == address(0), "ALREADY_MINTED"); // Counter overflow is incredibly unrealistic. unchecked { _balanceOf[to]++; } _ownerOf[id] = to; emit Transfer(address(0), to, id); } function _burn(uint256 id) internal virtual { address owner = _ownerOf[id]; require(owner != address(0), "NOT_MINTED"); // Ownership check above ensures no underflow. unchecked { _balanceOf[owner]--; } delete _ownerOf[id]; delete getApproved[id]; emit Transfer(owner, address(0), id); } /*////////////////////////////////////////////////////////////// INTERNAL SAFE MINT LOGIC //////////////////////////////////////////////////////////////*/ function _safeMint(address to, uint256 id) internal virtual { _mint(to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } function _safeMint( address to, uint256 id, bytes memory data ) internal virtual { _mint(to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } } /// @notice A generic interface for a contract which properly accepts ERC721 tokens. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol) abstract contract ERC721TokenReceiver { function onERC721Received( address, address, uint256, bytes calldata ) external virtual returns (bytes4) { return ERC721TokenReceiver.onERC721Received.selector; } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Arithmetic library with operations for fixed-point numbers. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol) /// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol) library FixedPointMathLib { /*////////////////////////////////////////////////////////////// SIMPLIFIED FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ uint256 internal constant MAX_UINT256 = 2**256 - 1; uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s. function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down. } function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up. } function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down. } function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up. } /*////////////////////////////////////////////////////////////// LOW LEVEL FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ function mulDivDown( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // Divide x * y by the denominator. z := div(mul(x, y), denominator) } } function mulDivUp( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // If x * y modulo the denominator is strictly greater than 0, // 1 is added to round up the division of x * y by the denominator. z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator)) } } function rpow( uint256 x, uint256 n, uint256 scalar ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { switch x case 0 { switch n case 0 { // 0 ** 0 = 1 z := scalar } default { // 0 ** n = 0 z := 0 } } default { switch mod(n, 2) case 0 { // If n is even, store scalar in z for now. z := scalar } default { // If n is odd, store x in z for now. z := x } // Shifting right by 1 is like dividing by 2. let half := shr(1, scalar) for { // Shift n right by 1 before looping to halve it. n := shr(1, n) } n { // Shift n right by 1 each iteration to halve it. n := shr(1, n) } { // Revert immediately if x ** 2 would overflow. // Equivalent to iszero(eq(div(xx, x), x)) here. if shr(128, x) { revert(0, 0) } // Store x squared. let xx := mul(x, x) // Round to the nearest number. let xxRound := add(xx, half) // Revert if xx + half overflowed. if lt(xxRound, xx) { revert(0, 0) } // Set x to scaled xxRound. x := div(xxRound, scalar) // If n is even: if mod(n, 2) { // Compute z * x. let zx := mul(z, x) // If z * x overflowed: if iszero(eq(div(zx, x), z)) { // Revert if x is non-zero. if iszero(iszero(x)) { revert(0, 0) } } // Round to the nearest number. let zxRound := add(zx, half) // Revert if zx + half overflowed. if lt(zxRound, zx) { revert(0, 0) } // Return properly scaled zxRound. z := div(zxRound, scalar) } } } } } /*////////////////////////////////////////////////////////////// GENERAL NUMBER UTILITIES //////////////////////////////////////////////////////////////*/ function sqrt(uint256 x) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { let y := x // We start y at x, which will help us make our initial estimate. z := 181 // The "correct" value is 1, but this saves a multiplication later. // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically. // We check y >= 2^(k + 8) but shift right by k bits // each branch to ensure that if x >= 256, then y >= 256. if iszero(lt(y, 0x10000000000000000000000000000000000)) { y := shr(128, y) z := shl(64, z) } if iszero(lt(y, 0x1000000000000000000)) { y := shr(64, y) z := shl(32, z) } if iszero(lt(y, 0x10000000000)) { y := shr(32, y) z := shl(16, z) } if iszero(lt(y, 0x1000000)) { y := shr(16, y) z := shl(8, z) } // Goal was to get z*z*y within a small factor of x. More iterations could // get y in a tighter range. Currently, we will have y in [256, 256*2^16). // We ensured y >= 256 so that the relative difference between y and y+1 is small. // That's not possible if x < 256 but we can just verify those cases exhaustively. // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256. // Correctness can be checked exhaustively for x < 256, so we assume y >= 256. // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps. // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256. // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18. // There is no overflow risk here since y < 2^136 after the first branch above. z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181. // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough. z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) // If x+1 is a perfect square, the Babylonian method cycles between // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor. // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case. // If you don't care whether the floor or ceil square root is returned, you can remove this statement. z := sub(z, lt(div(x, z), z)) } } function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Mod x by y. Note this will return // 0 instead of reverting if y is zero. z := mod(x, y) } } function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) { /// @solidity memory-safe-assembly assembly { // Divide x by y. Note this will return // 0 instead of reverting if y is zero. r := div(x, y) } } function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Add 1 to x * y if x % y > 0. Note this will // return 0 instead of reverting if y is zero. z := add(gt(mod(x, y), 0), div(x, y)) } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; /// @notice Efficient library for creating string representations of integers. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol) /// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol) library LibString { function toString(uint256 value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes. let newFreeMemoryPointer := add(mload(0x40), 160) // Update the free memory pointer to avoid overriding our string. mstore(0x40, newFreeMemoryPointer) // Assign str to the end of the zone of newly allocated memory. str := sub(newFreeMemoryPointer, 32) // Clean the last word of memory it may not be overwritten. mstore(str, 0) // Cache the end of the memory to calculate the length later. let end := str // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. // prettier-ignore for { let temp := value } 1 {} { // Move the pointer 1 byte to the left. str := sub(str, 1) // Write the character to the pointer. // The ASCII index of the '0' character is 48. mstore8(str, add(48, mod(temp, 10))) // Keep dividing temp until zero. temp := div(temp, 10) // prettier-ignore if iszero(temp) { break } } // Compute and cache the final total length of the string. let length := sub(end, str) // Move the pointer 32 bytes leftwards to make room for the length. str := sub(str, 32) // Store the string's length at the start of memory allocated for our string. mstore(str, length) } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; /// @notice Gas optimized merkle proof verification library. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol) /// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/MerkleProofLib.sol) library MerkleProofLib { function verify( bytes32[] calldata proof, bytes32 root, bytes32 leaf ) internal pure returns (bool isValid) { /// @solidity memory-safe-assembly assembly { if proof.length { // Left shifting by 5 is like multiplying by 32. let end := add(proof.offset, shl(5, proof.length)) // Initialize offset to the offset of the proof in calldata. let offset := proof.offset // Iterate over proof elements to compute root hash. // prettier-ignore for {} 1 {} { // Slot where the leaf should be put in scratch space. If // leaf > calldataload(offset): slot 32, otherwise: slot 0. let leafSlot := shl(5, gt(leaf, calldataload(offset))) // Store elements to hash contiguously in scratch space. // The xor puts calldataload(offset) in whichever slot leaf // is not occupying, so 0 if leafSlot is 32, and 32 otherwise. mstore(leafSlot, leaf) mstore(xor(leafSlot, 32), calldataload(offset)) // Reuse leaf to store the hash to reduce stack operations. leaf := keccak256(0, 64) // Hash both slots of scratch space. offset := add(offset, 32) // Shift 1 word per cycle. // prettier-ignore if iszero(lt(offset, end)) { break } } } isValid := eq(leaf, root) // The proof is valid if the roots match. } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; /// @notice Signed 18 decimal fixed point (wad) arithmetic library. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SignedWadMath.sol) /// @author Modified from Remco Bloemen (https://xn--2-umb.com/22/exp-ln/index.html) /// @dev Will not revert on overflow, only use where overflow is not possible. function toWadUnsafe(uint256 x) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Multiply x by 1e18. r := mul(x, 1000000000000000000) } } /// @dev Takes an integer amount of seconds and converts it to a wad amount of days. /// @dev Will not revert on overflow, only use where overflow is not possible. /// @dev Not meant for negative second amounts, it assumes x is positive. function toDaysWadUnsafe(uint256 x) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Multiply x by 1e18 and then divide it by 86400. r := div(mul(x, 1000000000000000000), 86400) } } /// @dev Takes a wad amount of days and converts it to an integer amount of seconds. /// @dev Will not revert on overflow, only use where overflow is not possible. /// @dev Not meant for negative day amounts, it assumes x is positive. function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) { /// @solidity memory-safe-assembly assembly { // Multiply x by 86400 and then divide it by 1e18. r := div(mul(x, 86400), 1000000000000000000) } } /// @dev Will not revert on overflow, only use where overflow is not possible. function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Multiply x by y and divide by 1e18. r := sdiv(mul(x, y), 1000000000000000000) } } /// @dev Will return 0 instead of reverting if y is zero and will /// not revert on overflow, only use where overflow is not possible. function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Multiply x by 1e18 and divide it by y. r := sdiv(mul(x, 1000000000000000000), y) } } function wadMul(int256 x, int256 y) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Store x * y in r for now. r := mul(x, y) // Equivalent to require(x == 0 || (x * y) / x == y) if iszero(or(iszero(x), eq(sdiv(r, x), y))) { revert(0, 0) } // Scale the result down by 1e18. r := sdiv(r, 1000000000000000000) } } function wadDiv(int256 x, int256 y) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Store x * 1e18 in r for now. r := mul(x, 1000000000000000000) // Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x)) if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) { revert(0, 0) } // Divide r by y. r := sdiv(r, y) } } function wadExp(int256 x) pure returns (int256 r) { unchecked { // When the result is < 0.5 we return zero. This happens when // x <= floor(log(0.5e18) * 1e18) ~ -42e18 if (x <= -42139678854452767551) return 0; // When the result is > (2**255 - 1) / 1e18 we can not represent it as an // int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135. if (x >= 135305999368893231589) revert("EXP_OVERFLOW"); // x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96 // for more intermediate precision and a binary basis. This base conversion // is a multiplication by 1e18 / 2**96 = 5**18 / 2**78. x = (x << 78) / 5**18; // Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers // of two such that exp(x) = exp(x') * 2**k, where k is an integer. // Solving this gives k = round(x / log(2)) and x' = x - k * log(2). int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96; x = x - k * 54916777467707473351141471128; // k is in the range [-61, 195]. // Evaluate using a (6, 7)-term rational approximation. // p is made monic, we'll multiply by a scale factor later. int256 y = x + 1346386616545796478920950773328; y = ((y * x) >> 96) + 57155421227552351082224309758442; int256 p = y + x - 94201549194550492254356042504812; p = ((p * y) >> 96) + 28719021644029726153956944680412240; p = p * x + (4385272521454847904659076985693276 << 96); // We leave p in 2**192 basis so we don't need to scale it back up for the division. int256 q = x - 2855989394907223263936484059900; q = ((q * x) >> 96) + 50020603652535783019961831881945; q = ((q * x) >> 96) - 533845033583426703283633433725380; q = ((q * x) >> 96) + 3604857256930695427073651918091429; q = ((q * x) >> 96) - 14423608567350463180887372962807573; q = ((q * x) >> 96) + 26449188498355588339934803723976023; /// @solidity memory-safe-assembly assembly { // Div in assembly because solidity adds a zero check despite the unchecked. // The q polynomial won't have zeros in the domain as all its roots are complex. // No scaling is necessary because p is already 2**96 too large. r := sdiv(p, q) } // r should be in the range (0.09, 0.25) * 2**96. // We now need to multiply r by: // * the scale factor s = ~6.031367120. // * the 2**k factor from the range reduction. // * the 1e18 / 2**96 factor for base conversion. // We do this all at once, with an intermediate result in 2**213 // basis, so the final right shift is always by a positive amount. r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)); } } function wadLn(int256 x) pure returns (int256 r) { unchecked { require(x > 0, "UNDEFINED"); // We want to convert x from 10**18 fixed point to 2**96 fixed point. // We do this by multiplying by 2**96 / 10**18. But since // ln(x * C) = ln(x) + ln(C), we can simply do nothing here // and add ln(2**96 / 10**18) at the end. /// @solidity memory-safe-assembly assembly { r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x)) r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x)))) r := or(r, shl(5, lt(0xffffffff, shr(r, x)))) r := or(r, shl(4, lt(0xffff, shr(r, x)))) r := or(r, shl(3, lt(0xff, shr(r, x)))) r := or(r, shl(2, lt(0xf, shr(r, x)))) r := or(r, shl(1, lt(0x3, shr(r, x)))) r := or(r, lt(0x1, shr(r, x))) } // Reduce range of x to (1, 2) * 2**96 // ln(2^k * x) = k * ln(2) + ln(x) int256 k = r - 96; x <<= uint256(159 - k); x = int256(uint256(x) >> 159); // Evaluate using a (8, 8)-term rational approximation. // p is made monic, we will multiply by a scale factor later. int256 p = x + 3273285459638523848632254066296; p = ((p * x) >> 96) + 24828157081833163892658089445524; p = ((p * x) >> 96) + 43456485725739037958740375743393; p = ((p * x) >> 96) - 11111509109440967052023855526967; p = ((p * x) >> 96) - 45023709667254063763336534515857; p = ((p * x) >> 96) - 14706773417378608786704636184526; p = p * x - (795164235651350426258249787498 << 96); // We leave p in 2**192 basis so we don't need to scale it back up for the division. // q is monic by convention. int256 q = x + 5573035233440673466300451813936; q = ((q * x) >> 96) + 71694874799317883764090561454958; q = ((q * x) >> 96) + 283447036172924575727196451306956; q = ((q * x) >> 96) + 401686690394027663651624208769553; q = ((q * x) >> 96) + 204048457590392012362485061816622; q = ((q * x) >> 96) + 31853899698501571402653359427138; q = ((q * x) >> 96) + 909429971244387300277376558375; /// @solidity memory-safe-assembly assembly { // Div in assembly because solidity adds a zero check despite the unchecked. // The q polynomial is known not to have zeros in the domain. // No scaling required because p is already 2**96 too large. r := sdiv(p, q) } // r is in the range (0, 0.125) * 2**96 // Finalization, we need to: // * multiply by the scale factor s = 5.549… // * add ln(2**96 / 10**18) // * add k * ln(2) // * multiply by 10**18 / 2**96 = 5**18 >> 78 // mul s * 5e18 * 2**96, base is now 5**18 * 2**192 r *= 1677202110996718588342820967067443963516166; // add ln(2) * k * 5e18 * 2**192 r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k; // add ln(2**96 / 10**18) * 5e18 * 2**192 r += 600920179829731861736702779321621459595472258049074101567377883020018308; // base conversion: mul 2**18 / 2**192 r >>= 174; } } /// @dev Will return 0 instead of reverting if y is zero. function unsafeDiv(int256 x, int256 y) pure returns (int256 r) { /// @solidity memory-safe-assembly assembly { // Divide x by y. r := sdiv(x, y) } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; /* **,/*, *%@&%#/*,,..........,/(%&@@#* %@%,..............................#@@% &&,.....,,...............................,/&@* (@*.....**............,/,.......................(@% &&......*,............./,.............**............&@ @#......**.............**..............,*........,*,..,@/ /@......,/............../,..............,*........../,..*@. #@,......................*.............../,..........**...#/ ,@&,.......................................*..........,/....(@ *@&(*...................................................../*....(@ @(..*%@@&%#(#@@@%%%%%&&@@@@@@@@@&&#(///..........................#@ @%/@@@&%&&&@@&%%%%%%%#(/(((/(/(/(/(/(/(/(/(%%&@@@%(/,............#& @@@#/**./@%%%&%#/*************./(%@@@@&(*********(@&&@@@%(.....,&@ ,@/.//(&@@/. .#@%/******./&&*, ./@&********%@/**(@#@@#,..(@ #%****%@. %@/****./&@ ,. %&********%@(**&@...(@#.#@ &#**./@/ %@&& .@#****./@* &@@@@& .@/******./@@((((@&....(@ ##**./&@ ,&@@@, #@/****./@@ @@. .@&*******./@%****%@@@(, ,@/**./%@(. .*@@/********(&@#*,,,,/&@%/*******./@@&&&@@@# @&/**@&/%&&&&&%/**.//////*********./************./@&******@* /@@@@&(////#%&@@&(**./#&@@&(//*************./&@(********#@ .@#**.///*****************(#@@@&&&&&@@@@&%(**********./@, @(*****%@#*********************&@#*********************(@ @****./@#*./@@#//***.///(%@%*****%@*********************#@ #&****./@%************************&@**********************@% .@/******.//*******************./@@(************************@/ /@**********************************************************(@, @#*****************************************************%@@@@@@@. *@/*************************************************************#@( @%***************************************************************./@( /@@&&&@@ .@/*******************************************************************&@ @%######%@. @#***************************./%&&&%(**************#%******************&# @%######&@%&@@. ,@(***./&#********************#@&#####%@&*************&%****************./@, &&*,/@%######&@@@*.*@&, @@****./@&*******************./%@#######%@#***********./@&*****************(@ ((...*%@&##%@@,..........,,,,%@&@%/*****&%****************./&@#*%@#######&@*#@%*********./@&*****************(@, (@#....(@%#&&,...,/...........@(*******(@(****************(@/...*%@@@@@@%*....&@@@@&@@@@@@%/%@@##(************(@. ((./(((%@%#&@/,/&@/...........%&*******%@****************./@%,.................#,............/@%***************#@ *@@####@@%###%&@(@(...........%&*******%@****************%@,,#%/..............................#@/***************&/ (#.....,&&####&@..%%..........%%*****(@@#****************#@,...................................@(***************(@ .@@&%%&@@&####&&.............,@(***%@(**********./#%%%%%##&@&#(,...............................#@****************&. &#.....(@%###&@*............%@**%@(*******(&@&%#/////////@%...................................#@***************&@ #@@@@&%####&@&&&,........%@./@%*****(@@%////////////////@@@%,...............................#@**************#@ @@&&&&@@( /&@@&%%@&@@@%**./&@(///////////////////@%.................................,@(*********./%@&. (@//@% @%***&&(//////////////////////(&@(**,,,,./(%&@@@%/*,,****,,***./@@&&&&&&&&#//%@ (@//%@ (@(*#@#////////////////////////////%@@%%%&@@#////%@/***************************&& (@//%@ .,,,,/#&&&&&&@&*#@#///////////////////////////////@%//&&///////#@(***************************@&(#@@@@@&(*. ,@@@@@&&@//%@,,.,,,,,.,..,,#@./@%////////////////////////////////%@**&&////////(@(**************************&#,,,,,,,,,,,,/(#&@& &@%*,,,,,,,,#@//%@,,,,,,,,,,,,,,&%*#@(////////////////////////////////%@**&&/////////&@**************************#@.,,,.,,.,,&#.,,...,%@ (@/,,,,,,,,,,,,(@(/%@,,,,,,,,,,,,,,&%*#@(////////////////////////////////%@./%@/////////#@(*************************&%,,,(%@@@@#*,. .,/@. &%.. *&@%/,.,#@(*#@*,,.,,,,,,,,,,%@/#@(////////////////////////////////%@**#@/////////#@(*****************.//#%@@@@%%(/,... ...,,,%& ,@*.,. ../((%&&@@@&%#((///,,,,,/@&(@(////////////////////////////////@&**#@/////////%@%###%&&&&@@@@@@%%#(**,,,,,,. ..,,,,,,,,,,%# @(,,,,,.., ,.. ..,,,**(%%%&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%%(((,,.,.,,,,,,.,..,,,,.,.,,,,.,..,.,,.,,,,,.,,,,,,,,,.*@% @%,,,,,,,,,,,,,,,.,.,,, .,.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,,,.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,.,,,,,,#@@, ,@@(,.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,,.,,.,.,./#%&@@@@@# .@#&@@@@@%*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,/&@@@@@%&@%((((#@@. .@%((((#@@@/#&@@@@&%#/*,.,..,,,,.,,,,,.,.,,,,,,,,,,,,,,,,..,.,..,,...,,,...,,,,,,.,,,,,,,,,,,../#%&@@@@@@@&%((///*********./(((/&& %@&%%#/***********./////(((((((####%%&&@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@@&&%%%%%%%%#((((((((%@&#(((((#%@%/*******************./*/ import {Owned} from "solmate/auth/Owned.sol"; import {ERC721} from "solmate/tokens/ERC721.sol"; import {LibString} from "solmate/utils/LibString.sol"; import {MerkleProofLib} from "solmate/utils/MerkleProofLib.sol"; import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol"; import {ERC1155, ERC1155TokenReceiver} from "solmate/tokens/ERC1155.sol"; import {toWadUnsafe, toDaysWadUnsafe} from "solmate/utils/SignedWadMath.sol"; import {LibGOO} from "goo-issuance/LibGOO.sol"; import {LogisticVRGDA} from "VRGDAs/LogisticVRGDA.sol"; import {RandProvider} from "./utils/rand/RandProvider.sol"; import {GobblersERC721} from "./utils/token/GobblersERC721.sol"; import {Goo} from "./Goo.sol"; import {Pages} from "./Pages.sol"; /// @title Art Gobblers NFT /// @author FrankieIsLost <[email protected]> /// @author transmissions11 <[email protected]> /// @notice An experimental decentralized art factory by Justin Roiland and Paradigm. contract ArtGobblers is GobblersERC721, LogisticVRGDA, Owned, ERC1155TokenReceiver { using LibString for uint256; using FixedPointMathLib for uint256; /*////////////////////////////////////////////////////////////// ADDRESSES //////////////////////////////////////////////////////////////*/ /// @notice The address of the Goo ERC20 token contract. Goo public immutable goo; /// @notice The address of the Pages ERC721 token contract. Pages public immutable pages; /// @notice The address which receives gobblers reserved for the team. address public immutable team; /// @notice The address which receives gobblers reserved for the community. address public immutable community; /// @notice The address of a randomness provider. This provider will initially be /// a wrapper around Chainlink VRF v1, but can be changed in case it is fully sunset. RandProvider public randProvider; /*////////////////////////////////////////////////////////////// SUPPLY CONSTANTS //////////////////////////////////////////////////////////////*/ /// @notice Maximum number of mintable gobblers. uint256 public constant MAX_SUPPLY = 10000; /// @notice Maximum amount of gobblers mintable via mintlist. uint256 public constant MINTLIST_SUPPLY = 2000; /// @notice Maximum amount of mintable legendary gobblers. uint256 public constant LEGENDARY_SUPPLY = 10; /// @notice Maximum amount of gobblers split between the reserves. /// @dev Set to comprise 20% of the sum of goo mintable gobblers + reserved gobblers. uint256 public constant RESERVED_SUPPLY = (MAX_SUPPLY - MINTLIST_SUPPLY - LEGENDARY_SUPPLY) / 5; /// @notice Maximum amount of gobblers that can be minted via VRGDA. // prettier-ignore uint256 public constant MAX_MINTABLE = MAX_SUPPLY - MINTLIST_SUPPLY - LEGENDARY_SUPPLY - RESERVED_SUPPLY; /*////////////////////////////////////////////////////////////// METADATA CONSTANTS //////////////////////////////////////////////////////////////*/ /// @notice Provenance hash for gobbler metadata. bytes32 public immutable PROVENANCE_HASH; /// @notice URI for gobblers pending reveal. string public UNREVEALED_URI; /// @notice Base URI for minted gobblers. string public BASE_URI; /*////////////////////////////////////////////////////////////// MINTLIST STATE //////////////////////////////////////////////////////////////*/ /// @notice Merkle root of mint mintlist. bytes32 public immutable merkleRoot; /// @notice Mapping to keep track of which addresses have claimed from mintlist. mapping(address => bool) public hasClaimedMintlistGobbler; /*////////////////////////////////////////////////////////////// VRGDA INPUT STATE //////////////////////////////////////////////////////////////*/ /// @notice Timestamp for the start of minting. uint256 public immutable mintStart; /// @notice Number of gobblers minted from goo. uint128 public numMintedFromGoo; /*////////////////////////////////////////////////////////////// STANDARD GOBBLER STATE //////////////////////////////////////////////////////////////*/ /// @notice Id of the most recently minted non legendary gobbler. /// @dev Will be 0 if no non legendary gobblers have been minted yet. uint128 public currentNonLegendaryId; /// @notice The number of gobblers minted to the reserves. uint256 public numMintedForReserves; /*////////////////////////////////////////////////////////////// LEGENDARY GOBBLER AUCTION STATE //////////////////////////////////////////////////////////////*/ /// @notice Initial legendary gobbler auction price. uint256 public constant LEGENDARY_GOBBLER_INITIAL_START_PRICE = 69; /// @notice The last LEGENDARY_SUPPLY ids are reserved for legendary gobblers. uint256 public constant FIRST_LEGENDARY_GOBBLER_ID = MAX_SUPPLY - LEGENDARY_SUPPLY + 1; /// @notice Legendary auctions begin each time a multiple of these many gobblers have been minted from goo. /// @dev We add 1 to LEGENDARY_SUPPLY because legendary auctions begin only after the first interval. uint256 public constant LEGENDARY_AUCTION_INTERVAL = MAX_MINTABLE / (LEGENDARY_SUPPLY + 1); /// @notice Struct holding data required for legendary gobbler auctions. struct LegendaryGobblerAuctionData { // Start price of current legendary gobbler auction. uint128 startPrice; // Number of legendary gobblers sold so far. uint128 numSold; } /// @notice Data about the current legendary gobbler auction. LegendaryGobblerAuctionData public legendaryGobblerAuctionData; /*////////////////////////////////////////////////////////////// GOBBLER REVEAL STATE //////////////////////////////////////////////////////////////*/ /// @notice Struct holding data required for gobbler reveals. struct GobblerRevealsData { // Last randomness obtained from the rand provider. uint64 randomSeed; // Next reveal cannot happen before this timestamp. uint64 nextRevealTimestamp; // Id of latest gobbler which has been revealed so far. uint64 lastRevealedId; // Remaining gobblers to be revealed with the current seed. uint56 toBeRevealed; // Whether we are waiting to receive a seed from the provider. bool waitingForSeed; } /// @notice Data about the current state of gobbler reveals. GobblerRevealsData public gobblerRevealsData; /*////////////////////////////////////////////////////////////// GOBBLED ART STATE //////////////////////////////////////////////////////////////*/ /// @notice Maps gobbler ids to NFT contracts and their ids to the # of those NFT ids gobbled by the gobbler. mapping(uint256 => mapping(address => mapping(uint256 => uint256))) public getCopiesOfArtGobbledByGobbler; /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event GooBalanceUpdated(address indexed user, uint256 newGooBalance); event GobblerClaimed(address indexed user, uint256 indexed gobblerId); event GobblerPurchased(address indexed user, uint256 indexed gobblerId, uint256 price); event LegendaryGobblerMinted(address indexed user, uint256 indexed gobblerId, uint256[] burnedGobblerIds); event ReservedGobblersMinted(address indexed user, uint256 lastMintedGobblerId, uint256 numGobblersEach); event RandomnessFulfilled(uint256 randomness); event RandomnessRequested(address indexed user, uint256 toBeRevealed); event RandProviderUpgraded(address indexed user, RandProvider indexed newRandProvider); event GobblersRevealed(address indexed user, uint256 numGobblers, uint256 lastRevealedId); event ArtGobbled(address indexed user, uint256 indexed gobblerId, address indexed nft, uint256 id); /*////////////////////////////////////////////////////////////// ERRORS //////////////////////////////////////////////////////////////*/ error InvalidProof(); error AlreadyClaimed(); error MintStartPending(); error SeedPending(); error RevealsPending(); error RequestTooEarly(); error ZeroToBeRevealed(); error NotRandProvider(); error ReserveImbalance(); error Cannibalism(); error OwnerMismatch(address owner); error NoRemainingLegendaryGobblers(); error CannotBurnLegendary(uint256 gobblerId); error InsufficientGobblerAmount(uint256 cost); error LegendaryAuctionNotStarted(uint256 gobblersLeft); error PriceExceededMax(uint256 currentPrice); error NotEnoughRemainingToBeRevealed(uint256 totalRemainingToBeRevealed); error UnauthorizedCaller(address caller); /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ /// @notice Sets VRGDA parameters, mint config, relevant addresses, and URIs. /// @param _merkleRoot Merkle root of mint mintlist. /// @param _mintStart Timestamp for the start of the VRGDA mint. /// @param _goo Address of the Goo contract. /// @param _team Address of the team reserve. /// @param _community Address of the community reserve. /// @param _randProvider Address of the randomness provider. /// @param _baseUri Base URI for revealed gobblers. /// @param _unrevealedUri URI for unrevealed gobblers. /// @param _provenanceHash Provenance Hash for gobbler metadata. constructor( // Mint config: bytes32 _merkleRoot, uint256 _mintStart, // Addresses: Goo _goo, Pages _pages, address _team, address _community, RandProvider _randProvider, // URIs: string memory _baseUri, string memory _unrevealedUri, // Provenance: bytes32 _provenanceHash ) GobblersERC721("Art Gobblers", "GOBBLER") Owned(msg.sender) LogisticVRGDA( 69.42e18, // Target price. 0.31e18, // Price decay percent. // Max gobblers mintable via VRGDA. toWadUnsafe(MAX_MINTABLE), 0.0023e18 // Time scale. ) { mintStart = _mintStart; merkleRoot = _merkleRoot; goo = _goo; pages = _pages; team = _team; community = _community; randProvider = _randProvider; BASE_URI = _baseUri; UNREVEALED_URI = _unrevealedUri; PROVENANCE_HASH = _provenanceHash; // Set the starting price for the first legendary gobbler auction. legendaryGobblerAuctionData.startPrice = uint128(LEGENDARY_GOBBLER_INITIAL_START_PRICE); // Reveal for initial mint must wait a day from the start of the mint. gobblerRevealsData.nextRevealTimestamp = uint64(_mintStart + 1 days); } /*////////////////////////////////////////////////////////////// MINTLIST CLAIM LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Claim from mintlist, using a merkle proof. /// @dev Function does not directly enforce the MINTLIST_SUPPLY limit for gas efficiency. The /// limit is enforced during the creation of the merkle proof, which will be shared publicly. /// @param proof Merkle proof to verify the sender is mintlisted. /// @return gobblerId The id of the gobbler that was claimed. function claimGobbler(bytes32[] calldata proof) external returns (uint256 gobblerId) { // If minting has not yet begun, revert. if (mintStart > block.timestamp) revert MintStartPending(); // If the user has already claimed, revert. if (hasClaimedMintlistGobbler[msg.sender]) revert AlreadyClaimed(); // If the user's proof is invalid, revert. if (!MerkleProofLib.verify(proof, merkleRoot, keccak256(abi.encodePacked(msg.sender)))) revert InvalidProof(); hasClaimedMintlistGobbler[msg.sender] = true; unchecked { // Overflow should be impossible due to supply cap of 10,000. emit GobblerClaimed(msg.sender, gobblerId = ++currentNonLegendaryId); } _mint(msg.sender, gobblerId); } /*////////////////////////////////////////////////////////////// MINTING LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Mint a gobbler, paying with goo. /// @param maxPrice Maximum price to pay to mint the gobbler. /// @param useVirtualBalance Whether the cost is paid from the /// user's virtual goo balance, or from their ERC20 goo balance. /// @return gobblerId The id of the gobbler that was minted. function mintFromGoo(uint256 maxPrice, bool useVirtualBalance) external returns (uint256 gobblerId) { // No need to check if we're at MAX_MINTABLE, // gobblerPrice() will revert once we reach it due to its // logistic nature. It will also revert prior to the mint start. uint256 currentPrice = gobblerPrice(); // If the current price is above the user's specified max, revert. if (currentPrice > maxPrice) revert PriceExceededMax(currentPrice); // Decrement the user's goo balance by the current // price, either from virtual balance or ERC20 balance. useVirtualBalance ? updateUserGooBalance(msg.sender, currentPrice, GooBalanceUpdateType.DECREASE) : goo.burnForGobblers(msg.sender, currentPrice); unchecked { ++numMintedFromGoo; // Overflow should be impossible due to the supply cap. emit GobblerPurchased(msg.sender, gobblerId = ++currentNonLegendaryId, currentPrice); } _mint(msg.sender, gobblerId); } /// @notice Gobbler pricing in terms of goo. /// @dev Will revert if called before minting starts /// or after all gobblers have been minted via VRGDA. /// @return Current price of a gobbler in terms of goo. function gobblerPrice() public view returns (uint256) { // We need checked math here to cause underflow // before minting has begun, preventing mints. uint256 timeSinceStart = block.timestamp - mintStart; return getVRGDAPrice(toDaysWadUnsafe(timeSinceStart), numMintedFromGoo); } /*////////////////////////////////////////////////////////////// LEGENDARY GOBBLER AUCTION LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Mint a legendary gobbler by burning multiple standard gobblers. /// @param gobblerIds The ids of the standard gobblers to burn. /// @return gobblerId The id of the legendary gobbler that was minted. function mintLegendaryGobbler(uint256[] calldata gobblerIds) external returns (uint256 gobblerId) { // Get the number of legendary gobblers sold up until this point. uint256 numSold = legendaryGobblerAuctionData.numSold; gobblerId = FIRST_LEGENDARY_GOBBLER_ID + numSold; // Assign id. // This will revert if the auction hasn't started yet or legendaries // have sold out entirely, so there is no need to check here as well. uint256 cost = legendaryGobblerPrice(); if (gobblerIds.length < cost) revert InsufficientGobblerAmount(cost); // Overflow should not occur in here, as most math is on emission multiples, which are inherently small. unchecked { uint256 burnedMultipleTotal; // The legendary's emissionMultiple will be 2x the sum of the gobblers burned. /*////////////////////////////////////////////////////////////// BATCH BURN LOGIC //////////////////////////////////////////////////////////////*/ uint256 id; // Storing outside the loop saves ~7 gas per iteration. for (uint256 i = 0; i < cost; ++i) { id = gobblerIds[i]; if (id >= FIRST_LEGENDARY_GOBBLER_ID) revert CannotBurnLegendary(id); GobblerData storage gobbler = getGobblerData[id]; require(gobbler.owner == msg.sender, "WRONG_FROM"); burnedMultipleTotal += gobbler.emissionMultiple; delete getApproved[id]; emit Transfer(msg.sender, gobbler.owner = address(0), id); } /*////////////////////////////////////////////////////////////// LEGENDARY MINTING LOGIC //////////////////////////////////////////////////////////////*/ // The legendary's emissionMultiple is 2x the sum of the multiples of the gobblers burned. getGobblerData[gobblerId].emissionMultiple = uint32(burnedMultipleTotal * 2); // Update the user's user data struct in one big batch. We add burnedMultipleTotal to their // emission multiple (not burnedMultipleTotal * 2) to account for the standard gobblers that // were burned and hence should have their multiples subtracted from the user's total multiple. getUserData[msg.sender].lastBalance = uint128(gooBalance(msg.sender)); // Checkpoint balance. getUserData[msg.sender].lastTimestamp = uint64(block.timestamp); // Store time alongside it. getUserData[msg.sender].emissionMultiple += uint32(burnedMultipleTotal); // Update multiple. // Update the total number of gobblers owned by the user. The call to _mint // below will increase the count by 1 to account for the new legendary gobbler. getUserData[msg.sender].gobblersOwned -= uint32(cost); // New start price is the max of LEGENDARY_GOBBLER_INITIAL_START_PRICE and cost * 2. legendaryGobblerAuctionData.startPrice = uint128( cost <= LEGENDARY_GOBBLER_INITIAL_START_PRICE / 2 ? LEGENDARY_GOBBLER_INITIAL_START_PRICE : cost * 2 ); legendaryGobblerAuctionData.numSold = uint128(numSold + 1); // Increment the # of legendaries sold. // If gobblerIds has 1,000 elements this should cost around ~270,000 gas. emit LegendaryGobblerMinted(msg.sender, gobblerId, gobblerIds[:cost]); _mint(msg.sender, gobblerId); } } /// @notice Calculate the legendary gobbler price in terms of gobblers, according to a linear decay function. /// @dev The price of a legendary gobbler decays as gobblers are minted. The first legendary auction begins when /// 1 LEGENDARY_AUCTION_INTERVAL worth of gobblers are minted, and the price decays linearly while the next interval of /// gobblers are minted. Every time an additional interval is minted, a new auction begins until all legendaries have been sold. /// @dev Will revert if the auction hasn't started yet or legendaries have sold out entirely. /// @return The current price of the legendary gobbler being auctioned, in terms of gobblers. function legendaryGobblerPrice() public view returns (uint256) { // Retrieve and cache various auction parameters and variables. uint256 startPrice = legendaryGobblerAuctionData.startPrice; uint256 numSold = legendaryGobblerAuctionData.numSold; // If all legendary gobblers have been sold, there are none left to auction. if (numSold == LEGENDARY_SUPPLY) revert NoRemainingLegendaryGobblers(); unchecked { // Get and cache the number of standard gobblers sold via VRGDA up until this point. uint256 mintedFromGoo = numMintedFromGoo; // The number of gobblers minted at the start of the auction is computed by multiplying the # of // intervals that must pass before the next auction begins by the number of gobblers in each interval. uint256 numMintedAtStart = (numSold + 1) * LEGENDARY_AUCTION_INTERVAL; // If not enough gobblers have been minted to start the auction yet, return how many need to be minted. if (numMintedAtStart > mintedFromGoo) revert LegendaryAuctionNotStarted(numMintedAtStart - mintedFromGoo); // Compute how many gobblers were minted since the auction began. uint256 numMintedSinceStart = mintedFromGoo - numMintedAtStart; // prettier-ignore // If we've minted the full interval or beyond it, the price has decayed to 0. if (numMintedSinceStart >= LEGENDARY_AUCTION_INTERVAL) return 0; // Otherwise decay the price linearly based on what fraction of the interval has been minted. else return FixedPointMathLib.unsafeDivUp(startPrice * (LEGENDARY_AUCTION_INTERVAL - numMintedSinceStart), LEGENDARY_AUCTION_INTERVAL); } } /*////////////////////////////////////////////////////////////// RANDOMNESS LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Request a new random seed for revealing gobblers. function requestRandomSeed() external returns (bytes32) { uint256 nextRevealTimestamp = gobblerRevealsData.nextRevealTimestamp; // A new random seed cannot be requested before the next reveal timestamp. if (block.timestamp < nextRevealTimestamp) revert RequestTooEarly(); // A random seed can only be requested when all gobblers from the previous seed have been revealed. // This prevents a user from requesting additional randomness in hopes of a more favorable outcome. if (gobblerRevealsData.toBeRevealed != 0) revert RevealsPending(); unchecked { // Prevent revealing while we wait for the seed. gobblerRevealsData.waitingForSeed = true; // Compute the number of gobblers to be revealed with the seed. uint256 toBeRevealed = currentNonLegendaryId - gobblerRevealsData.lastRevealedId; // Ensure that there are more than 0 gobblers to be revealed, // otherwise the contract could waste LINK revealing nothing. if (toBeRevealed == 0) revert ZeroToBeRevealed(); // Lock in the number of gobblers to be revealed from seed. gobblerRevealsData.toBeRevealed = uint56(toBeRevealed); // We enable reveals for a set of gobblers every 24 hours. // Timestamp overflow is impossible on human timescales. gobblerRevealsData.nextRevealTimestamp = uint64(nextRevealTimestamp + 1 days); emit RandomnessRequested(msg.sender, toBeRevealed); } // Call out to the randomness provider. return randProvider.requestRandomBytes(); } /// @notice Callback from rand provider. Sets randomSeed. Can only be called by the rand provider. /// @param randomness The 256 bits of verifiable randomness provided by the rand provider. function acceptRandomSeed(bytes32, uint256 randomness) external { // The caller must be the randomness provider, revert in the case it's not. if (msg.sender != address(randProvider)) revert NotRandProvider(); // The unchecked cast to uint64 is equivalent to moduloing the randomness by 2**64. gobblerRevealsData.randomSeed = uint64(randomness); // 64 bits of randomness is plenty. gobblerRevealsData.waitingForSeed = false; // We have the seed now, open up reveals. emit RandomnessFulfilled(randomness); } /// @notice Upgrade the rand provider contract. Useful if current VRF is sunset. /// @param newRandProvider The new randomness provider contract address. function upgradeRandProvider(RandProvider newRandProvider) external onlyOwner { // Reset reveal state when we upgrade while the seed is pending. This gives us a // safeguard against malfunctions since we won't be stuck waiting for a seed forever. if (gobblerRevealsData.waitingForSeed) { gobblerRevealsData.waitingForSeed = false; gobblerRevealsData.toBeRevealed = 0; gobblerRevealsData.nextRevealTimestamp -= 1 days; } randProvider = newRandProvider; // Update the randomness provider. emit RandProviderUpgraded(msg.sender, newRandProvider); } /*////////////////////////////////////////////////////////////// GOBBLER REVEAL LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Knuth shuffle to progressively reveal /// new gobblers using entropy from a random seed. /// @param numGobblers The number of gobblers to reveal. function revealGobblers(uint256 numGobblers) external { uint256 randomSeed = gobblerRevealsData.randomSeed; uint256 lastRevealedId = gobblerRevealsData.lastRevealedId; uint256 totalRemainingToBeRevealed = gobblerRevealsData.toBeRevealed; // Can't reveal if we're still waiting for a new seed. if (gobblerRevealsData.waitingForSeed) revert SeedPending(); // Can't reveal more gobblers than are currently remaining to be revealed with the seed. if (numGobblers > totalRemainingToBeRevealed) revert NotEnoughRemainingToBeRevealed(totalRemainingToBeRevealed); // Implements a Knuth shuffle. If something in // here can overflow, we've got bigger problems. unchecked { for (uint256 i = 0; i < numGobblers; ++i) { /*////////////////////////////////////////////////////////////// DETERMINE RANDOM SWAP //////////////////////////////////////////////////////////////*/ // Number of ids that have not been revealed. Subtract 1 // because we don't want to include any legendaries in the swap. uint256 remainingIds = FIRST_LEGENDARY_GOBBLER_ID - lastRevealedId - 1; // Randomly pick distance for swap. uint256 distance = randomSeed % remainingIds; // Current id is consecutive to last reveal. uint256 currentId = ++lastRevealedId; // Select swap id, adding distance to next reveal id. uint256 swapId = currentId + distance; /*////////////////////////////////////////////////////////////// GET INDICES FOR IDS //////////////////////////////////////////////////////////////*/ // Get the index of the swap id. uint64 swapIndex = getGobblerData[swapId].idx == 0 ? uint64(swapId) // Hasn't been shuffled before. : getGobblerData[swapId].idx; // Shuffled before. // Get the owner of the current id. address currentIdOwner = getGobblerData[currentId].owner; // Get the index of the current id. uint64 currentIndex = getGobblerData[currentId].idx == 0 ? uint64(currentId) // Hasn't been shuffled before. : getGobblerData[currentId].idx; // Shuffled before. /*////////////////////////////////////////////////////////////// SWAP INDICES AND SET MULTIPLE //////////////////////////////////////////////////////////////*/ // Determine the current id's new emission multiple. uint256 newCurrentIdMultiple = 9; // For beyond 7963. // The branchless expression below is equivalent to: // if (swapIndex <= 3054) newCurrentIdMultiple = 6; // else if (swapIndex <= 5672) newCurrentIdMultiple = 7; // else if (swapIndex <= 7963) newCurrentIdMultiple = 8; assembly { // prettier-ignore newCurrentIdMultiple := sub(sub(sub( newCurrentIdMultiple, lt(swapIndex, 7964)), lt(swapIndex, 5673)), lt(swapIndex, 3055) ) } // Swap the index and multiple of the current id. getGobblerData[currentId].idx = swapIndex; getGobblerData[currentId].emissionMultiple = uint32(newCurrentIdMultiple); // Swap the index of the swap id. getGobblerData[swapId].idx = currentIndex; /*////////////////////////////////////////////////////////////// UPDATE CURRENT ID MULTIPLE //////////////////////////////////////////////////////////////*/ // Update the user data for the owner of the current id. getUserData[currentIdOwner].lastBalance = uint128(gooBalance(currentIdOwner)); getUserData[currentIdOwner].lastTimestamp = uint64(block.timestamp); getUserData[currentIdOwner].emissionMultiple += uint32(newCurrentIdMultiple); // Update the random seed to choose a new distance for the next iteration. // It is critical that we cast to uint64 here, as otherwise the random seed // set after calling revealGobblers(1) thrice would differ from the seed set // after calling revealGobblers(3) a single time. This would enable an attacker // to choose from a number of different seeds and use whichever is most favorable. // Equivalent to randomSeed = uint64(uint256(keccak256(abi.encodePacked(randomSeed)))) assembly { mstore(0, randomSeed) // Store the random seed in scratch space. // Moduloing by 2 ** 64 is equivalent to a uint64 cast. randomSeed := mod(keccak256(0, 32), exp(2, 64)) } } // Update all relevant reveal state. gobblerRevealsData.randomSeed = uint64(randomSeed); gobblerRevealsData.lastRevealedId = uint64(lastRevealedId); gobblerRevealsData.toBeRevealed = uint56(totalRemainingToBeRevealed - numGobblers); emit GobblersRevealed(msg.sender, numGobblers, lastRevealedId); } } /*////////////////////////////////////////////////////////////// URI LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Returns a token's URI if it has been minted. /// @param gobblerId The id of the token to get the URI for. function tokenURI(uint256 gobblerId) public view virtual override returns (string memory) { // Between 0 and lastRevealed are revealed normal gobblers. if (gobblerId <= gobblerRevealsData.lastRevealedId) { if (gobblerId == 0) revert("NOT_MINTED"); // 0 is not a valid id for Art Gobblers. return string.concat(BASE_URI, uint256(getGobblerData[gobblerId].idx).toString()); } // Between lastRevealed + 1 and currentNonLegendaryId are minted but not revealed. if (gobblerId <= currentNonLegendaryId) return UNREVEALED_URI; // Between currentNonLegendaryId and FIRST_LEGENDARY_GOBBLER_ID are unminted. if (gobblerId < FIRST_LEGENDARY_GOBBLER_ID) revert("NOT_MINTED"); // Between FIRST_LEGENDARY_GOBBLER_ID and FIRST_LEGENDARY_GOBBLER_ID + numSold are minted legendaries. if (gobblerId < FIRST_LEGENDARY_GOBBLER_ID + legendaryGobblerAuctionData.numSold) return string.concat(BASE_URI, gobblerId.toString()); revert("NOT_MINTED"); // Unminted legendaries and invalid token ids. } /*////////////////////////////////////////////////////////////// GOBBLE ART LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Feed a gobbler a work of art. /// @param gobblerId The gobbler to feed the work of art. /// @param nft The ERC721 or ERC1155 contract of the work of art. /// @param id The id of the work of art. /// @param isERC1155 Whether the work of art is an ERC1155 token. function gobble( uint256 gobblerId, address nft, uint256 id, bool isERC1155 ) external { // Get the owner of the gobbler to feed. address owner = getGobblerData[gobblerId].owner; // The caller must own the gobbler they're feeding. if (owner != msg.sender) revert OwnerMismatch(owner); // Gobblers have taken a vow not to eat other gobblers. if (nft == address(this)) revert Cannibalism(); unchecked { // Increment the # of copies gobbled by the gobbler. Unchecked is // safe, as an NFT can't have more than type(uint256).max copies. ++getCopiesOfArtGobbledByGobbler[gobblerId][nft][id]; } emit ArtGobbled(msg.sender, gobblerId, nft, id); isERC1155 ? ERC1155(nft).safeTransferFrom(msg.sender, address(this), id, 1, "") : ERC721(nft).transferFrom(msg.sender, address(this), id); } /*////////////////////////////////////////////////////////////// GOO LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Calculate a user's virtual goo balance. /// @param user The user to query balance for. function gooBalance(address user) public view returns (uint256) { // Compute the user's virtual goo balance using LibGOO. // prettier-ignore return LibGOO.computeGOOBalance( getUserData[user].emissionMultiple, getUserData[user].lastBalance, uint256(toDaysWadUnsafe(block.timestamp - getUserData[user].lastTimestamp)) ); } /// @notice Add goo to your emission balance, /// burning the corresponding ERC20 balance. /// @param gooAmount The amount of goo to add. function addGoo(uint256 gooAmount) external { // Burn goo being added to gobbler. goo.burnForGobblers(msg.sender, gooAmount); // Increase msg.sender's virtual goo balance. updateUserGooBalance(msg.sender, gooAmount, GooBalanceUpdateType.INCREASE); } /// @notice Remove goo from your emission balance, and /// add the corresponding amount to your ERC20 balance. /// @param gooAmount The amount of goo to remove. function removeGoo(uint256 gooAmount) external { // Decrease msg.sender's virtual goo balance. updateUserGooBalance(msg.sender, gooAmount, GooBalanceUpdateType.DECREASE); // Mint the corresponding amount of ERC20 goo. goo.mintForGobblers(msg.sender, gooAmount); } /// @notice Burn an amount of a user's virtual goo balance. Only callable /// by the Pages contract to enable purchasing pages with virtual balance. /// @param user The user whose virtual goo balance we should burn from. /// @param gooAmount The amount of goo to burn from the user's virtual balance. function burnGooForPages(address user, uint256 gooAmount) external { // The caller must be the Pages contract, revert otherwise. if (msg.sender != address(pages)) revert UnauthorizedCaller(msg.sender); // Burn the requested amount of goo from the user's virtual goo balance. // Will revert if the user doesn't have enough goo in their virtual balance. updateUserGooBalance(user, gooAmount, GooBalanceUpdateType.DECREASE); } /// @dev An enum for representing whether to /// increase or decrease a user's goo balance. enum GooBalanceUpdateType { INCREASE, DECREASE } /// @notice Update a user's virtual goo balance. /// @param user The user whose virtual goo balance we should update. /// @param gooAmount The amount of goo to update the user's virtual balance by. /// @param updateType Whether to increase or decrease the user's balance by gooAmount. function updateUserGooBalance( address user, uint256 gooAmount, GooBalanceUpdateType updateType ) internal { // Will revert due to underflow if we're decreasing by more than the user's current balance. // Don't need to do checked addition in the increase case, but we do it anyway for convenience. uint256 updatedBalance = updateType == GooBalanceUpdateType.INCREASE ? gooBalance(user) + gooAmount : gooBalance(user) - gooAmount; // Snapshot the user's new goo balance with the current timestamp. getUserData[user].lastBalance = uint128(updatedBalance); getUserData[user].lastTimestamp = uint64(block.timestamp); emit GooBalanceUpdated(user, updatedBalance); } /*////////////////////////////////////////////////////////////// RESERVED GOBBLERS MINTING LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Mint a number of gobblers to the reserves. /// @param numGobblersEach The number of gobblers to mint to each reserve. /// @dev Gobblers minted to reserves cannot comprise more than 20% of the sum of /// the supply of goo minted gobblers and the supply of gobblers minted to reserves. function mintReservedGobblers(uint256 numGobblersEach) external returns (uint256 lastMintedGobblerId) { unchecked { // Optimistically increment numMintedForReserves, may be reverted below. // Overflow in this calculation is possible but numGobblersEach would have to // be so large that it would cause the loop in _batchMint to run out of gas quickly. uint256 newNumMintedForReserves = numMintedForReserves += (numGobblersEach * 2); // Ensure that after this mint gobblers minted to reserves won't comprise more than 20% of // the sum of the supply of goo minted gobblers and the supply of gobblers minted to reserves. if (newNumMintedForReserves > (numMintedFromGoo + newNumMintedForReserves) / 5) revert ReserveImbalance(); } // Mint numGobblersEach gobblers to both the team and community reserve. lastMintedGobblerId = _batchMint(team, numGobblersEach, currentNonLegendaryId); lastMintedGobblerId = _batchMint(community, numGobblersEach, lastMintedGobblerId); currentNonLegendaryId = uint128(lastMintedGobblerId); // Set currentNonLegendaryId. emit ReservedGobblersMinted(msg.sender, lastMintedGobblerId, numGobblersEach); } /*////////////////////////////////////////////////////////////// CONVENIENCE FUNCTIONS //////////////////////////////////////////////////////////////*/ /// @notice Convenience function to get emissionMultiple for a gobbler. /// @param gobblerId The gobbler to get emissionMultiple for. function getGobblerEmissionMultiple(uint256 gobblerId) external view returns (uint256) { return getGobblerData[gobblerId].emissionMultiple; } /// @notice Convenience function to get emissionMultiple for a user. /// @param user The user to get emissionMultiple for. function getUserEmissionMultiple(address user) external view returns (uint256) { return getUserData[user].emissionMultiple; } /*////////////////////////////////////////////////////////////// ERC721 LOGIC //////////////////////////////////////////////////////////////*/ function transferFrom( address from, address to, uint256 id ) public override { require(from == getGobblerData[id].owner, "WRONG_FROM"); require(to != address(0), "INVALID_RECIPIENT"); require( msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id], "NOT_AUTHORIZED" ); delete getApproved[id]; getGobblerData[id].owner = to; unchecked { uint32 emissionMultiple = getGobblerData[id].emissionMultiple; // Caching saves gas. // We update their last balance before updating their emission multiple to avoid // penalizing them by retroactively applying their new (lower) emission multiple. getUserData[from].lastBalance = uint128(gooBalance(from)); getUserData[from].lastTimestamp = uint64(block.timestamp); getUserData[from].emissionMultiple -= emissionMultiple; getUserData[from].gobblersOwned -= 1; // We update their last balance before updating their emission multiple to avoid // overpaying them by retroactively applying their new (higher) emission multiple. getUserData[to].lastBalance = uint128(gooBalance(to)); getUserData[to].lastTimestamp = uint64(block.timestamp); getUserData[to].emissionMultiple += emissionMultiple; getUserData[to].gobblersOwned += 1; } emit Transfer(from, to, id); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {ERC20} from "solmate/tokens/ERC20.sol"; /* %#/*********(&, .#*********************#. #****./*********************% %*******************************% &**********************************,(( @(*,***********************************#& (*********************#***********************( ,%@/**************#%***%**&***%*******************, /********************#****#*#******,**************% ,************,#(*****************(#/&(*,*,*********# **************(%%(&************#@%(///************( ./**************,*./##****************************#*% #**&**************************************************&@@@@@&@&%#((./. (*******************@&%&@@@. / % &********(@/,****,,,*,,,****,,*,**********,*, &******************# / * / / .. %/****(******************,**&***********./ /%(*******************&***./# #.#%% ., ., ##&&@****#***********************************. *#(*,**************************(***(///.* * # # . %*****(/*************************************& *(***********************************.//****& # # (#&((%@*,*&(******(%************./@#* *%&%(/&*************( #,**************************************,&******&..*#&(*****,,,,/******************************** (/******,**,**, %*****************************************.//**************#************************************** .(***********# (*************************./************************************************************************ @************** ,**********&@@@&&%# &,**********************************************************************@ ./*,%*,********./ *********** .************@(*************(&#///////////////.//#&%/*****************&*,, &************% (**********. .%********************(&./////////////////////////////(%****************** *(**&,&##* #**********(, &,*./***************%(///////////////////////////////////*&**************** (************% %,*****************&///////////////////////////////////////*(***************. .(***************( #******************&//////////////////////////////////////////**************** .&*************%*./ .*******************%/////////////////////////////////////////****************## .*************%*% (********************#(///////////////////////////////////(#*****************&**,***,. #***./,***% #**********************,%%*./////////////////////////*(@*******************(/****./********,(( @@, &**@*****************************./(%@&%%((((((%&&%(*********************************&,**********. . .#,,*****./&/***************************************************************************************** %,******************************************************************************************************# %*******@*****************************************************./#%%,...((, .,********************( ,*******************************@&(**./%&%* .,//(//////////, ,************./ /**************************&* ////*(///////// ***(*********% (*********************(# ..///////////(//( .***********./ #******************% *..,,,(//////////(//(*.//, %***************& %***************** ////////&&&&&&&&%#(//(&@&#(#@@ &*********************# #****************. ,//(//////(@@%%%%%///////****& &************************( .**&***(************./ .@.,(///(/(.//(***((*(//*****@/& ,*************************./ &********************# .(#(@#//(****(//(*****(/(&(..&( ./*********************(#. #/***********************./ /,,./*((#%@(%&%(((((((#%&&&/(#(#@( #*,***********************,*& .%@@@&#, ///(/* (*************************% ..(/,./(,.,* /#/*./(%&(.*/ /// @title Goo Token (GOO) /// @author FrankieIsLost <[email protected]> /// @author transmissions11 <[email protected]> /// @notice Goo is the in-game token for ArtGobblers. It's a standard ERC20 /// token that can be burned and minted by the gobblers and pages contract. contract Goo is ERC20("Goo", "GOO", 18) { /*////////////////////////////////////////////////////////////// ADDRESSES //////////////////////////////////////////////////////////////*/ /// @notice The address of the Art Gobblers contract. address public immutable artGobblers; /// @notice The address of the Pages contract. address public immutable pages; /*////////////////////////////////////////////////////////////// ERRORS //////////////////////////////////////////////////////////////*/ error Unauthorized(); /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ /// @notice Sets the addresses of relevant contracts. /// @param _artGobblers Address of the ArtGobblers contract. /// @param _pages Address of the Pages contract. constructor(address _artGobblers, address _pages) { artGobblers = _artGobblers; pages = _pages; } /*////////////////////////////////////////////////////////////// MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Requires caller address to match user address. modifier only(address user) { if (msg.sender != user) revert Unauthorized(); _; } /// @notice Mint any amount of goo to a user. Can only be called by ArtGobblers. /// @param to The address of the user to mint goo to. /// @param amount The amount of goo to mint. function mintForGobblers(address to, uint256 amount) external only(artGobblers) { _mint(to, amount); } /// @notice Burn any amount of goo from a user. Can only be called by ArtGobblers. /// @param from The address of the user to burn goo from. /// @param amount The amount of goo to burn. function burnForGobblers(address from, uint256 amount) external only(artGobblers) { _burn(from, amount); } /// @notice Burn any amount of goo from a user. Can only be called by Pages. /// @param from The address of the user to burn goo from. /// @param amount The amount of goo to burn. function burnForPages(address from, uint256 amount) external only(pages) { _burn(from, amount); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; /// @title Randomness Provider Interface. /// @author FrankieIsLost <[email protected]> /// @author transmissions11 <[email protected]> /// @notice Generic asynchronous randomness provider interface. interface RandProvider { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event RandomBytesRequested(bytes32 requestId); event RandomBytesReturned(bytes32 requestId, uint256 randomness); /*////////////////////////////////////////////////////////////// FUNCTIONS //////////////////////////////////////////////////////////////*/ /// @dev Request random bytes from the randomness provider. function requestRandomBytes() external returns (bytes32 requestId); }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC721TokenReceiver} from "solmate/tokens/ERC721.sol"; /// @notice ERC721 implementation optimized for ArtGobblers by packing balanceOf/ownerOf with user/attribute data. /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol) abstract contract GobblersERC721 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 indexed id); event Approval(address indexed owner, address indexed spender, uint256 indexed id); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /*////////////////////////////////////////////////////////////// METADATA STORAGE/LOGIC //////////////////////////////////////////////////////////////*/ string public name; string public symbol; function tokenURI(uint256 id) external view virtual returns (string memory); /*////////////////////////////////////////////////////////////// GOBBLERS/ERC721 STORAGE //////////////////////////////////////////////////////////////*/ /// @notice Struct holding gobbler data. struct GobblerData { // The current owner of the gobbler. address owner; // Index of token after shuffle. uint64 idx; // Multiple on goo issuance. uint32 emissionMultiple; } /// @notice Maps gobbler ids to their data. mapping(uint256 => GobblerData) public getGobblerData; /// @notice Struct holding data relevant to each user's account. struct UserData { // The total number of gobblers currently owned by the user. uint32 gobblersOwned; // The sum of the multiples of all gobblers the user holds. uint32 emissionMultiple; // User's goo balance at time of last checkpointing. uint128 lastBalance; // Timestamp of the last goo balance checkpoint. uint64 lastTimestamp; } /// @notice Maps user addresses to their account data. mapping(address => UserData) public getUserData; function ownerOf(uint256 id) external view returns (address owner) { require((owner = getGobblerData[id].owner) != address(0), "NOT_MINTED"); } function balanceOf(address owner) external view returns (uint256) { require(owner != address(0), "ZERO_ADDRESS"); return getUserData[owner].gobblersOwned; } /*////////////////////////////////////////////////////////////// ERC721 APPROVAL STORAGE //////////////////////////////////////////////////////////////*/ mapping(uint256 => address) public getApproved; mapping(address => mapping(address => bool)) public isApprovedForAll; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor(string memory _name, string memory _symbol) { name = _name; symbol = _symbol; } /*////////////////////////////////////////////////////////////// ERC721 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 id) external { address owner = getGobblerData[id].owner; require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED"); getApproved[id] = spender; emit Approval(owner, spender, id); } function setApprovalForAll(address operator, bool approved) external { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function transferFrom( address from, address to, uint256 id ) public virtual; function safeTransferFrom( address from, address to, uint256 id ) external { transferFrom(from, to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } function safeTransferFrom( address from, address to, uint256 id, bytes calldata data ) external { transferFrom(from, to, id); require( to.code.length == 0 || ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } /*////////////////////////////////////////////////////////////// ERC165 LOGIC //////////////////////////////////////////////////////////////*/ function supportsInterface(bytes4 interfaceId) external pure returns (bool) { return interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165 interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721 interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata } /*////////////////////////////////////////////////////////////// INTERNAL MINT LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 id) internal { // Does not check if the token was already minted or the recipient is address(0) // because ArtGobblers.sol manages its ids in such a way that it ensures it won't // double mint and will only mint to safe addresses or msg.sender who cannot be zero. unchecked { ++getUserData[to].gobblersOwned; } getGobblerData[id].owner = to; emit Transfer(address(0), to, id); } function _batchMint( address to, uint256 amount, uint256 lastMintedId ) internal returns (uint256) { // Doesn't check if the tokens were already minted or the recipient is address(0) // because ArtGobblers.sol manages its ids in such a way that it ensures it won't // double mint and will only mint to safe addresses or msg.sender who cannot be zero. unchecked { getUserData[to].gobblersOwned += uint32(amount); for (uint256 i = 0; i < amount; ++i) { getGobblerData[++lastMintedId].owner = to; emit Transfer(address(0), to, lastMintedId); } } return lastMintedId; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; import {ERC721TokenReceiver} from "solmate/tokens/ERC721.sol"; import {ArtGobblers} from "../../ArtGobblers.sol"; /// @notice ERC721 implementation optimized for Pages by pre-approving them to the ArtGobblers contract. /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol) abstract contract PagesERC721 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 indexed id); event Approval(address indexed owner, address indexed spender, uint256 indexed id); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /*////////////////////////////////////////////////////////////// METADATA STORAGE/LOGIC //////////////////////////////////////////////////////////////*/ string public name; string public symbol; function tokenURI(uint256 id) external view virtual returns (string memory); /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ ArtGobblers public immutable artGobblers; constructor( ArtGobblers _artGobblers, string memory _name, string memory _symbol ) { name = _name; symbol = _symbol; artGobblers = _artGobblers; } /*////////////////////////////////////////////////////////////// ERC721 BALANCE/OWNER STORAGE //////////////////////////////////////////////////////////////*/ mapping(uint256 => address) internal _ownerOf; mapping(address => uint256) internal _balanceOf; function ownerOf(uint256 id) external view returns (address owner) { require((owner = _ownerOf[id]) != address(0), "NOT_MINTED"); } function balanceOf(address owner) external view returns (uint256) { require(owner != address(0), "ZERO_ADDRESS"); return _balanceOf[owner]; } /*////////////////////////////////////////////////////////////// ERC721 APPROVAL STORAGE //////////////////////////////////////////////////////////////*/ mapping(uint256 => address) public getApproved; mapping(address => mapping(address => bool)) internal _isApprovedForAll; function isApprovedForAll(address owner, address operator) public view returns (bool isApproved) { if (operator == address(artGobblers)) return true; // Skip approvals for the ArtGobblers contract. return _isApprovedForAll[owner][operator]; } /*////////////////////////////////////////////////////////////// ERC721 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 id) external { address owner = _ownerOf[id]; require(msg.sender == owner || isApprovedForAll(owner, msg.sender), "NOT_AUTHORIZED"); getApproved[id] = spender; emit Approval(owner, spender, id); } function setApprovalForAll(address operator, bool approved) external { _isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function transferFrom( address from, address to, uint256 id ) public { require(from == _ownerOf[id], "WRONG_FROM"); require(to != address(0), "INVALID_RECIPIENT"); require( msg.sender == from || isApprovedForAll(from, msg.sender) || msg.sender == getApproved[id], "NOT_AUTHORIZED" ); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. unchecked { _balanceOf[from]--; _balanceOf[to]++; } _ownerOf[id] = to; delete getApproved[id]; emit Transfer(from, to, id); } function safeTransferFrom( address from, address to, uint256 id ) external { transferFrom(from, to, id); if (to.code.length != 0) require( ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } function safeTransferFrom( address from, address to, uint256 id, bytes calldata data ) external { transferFrom(from, to, id); if (to.code.length != 0) require( ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) == ERC721TokenReceiver.onERC721Received.selector, "UNSAFE_RECIPIENT" ); } /*////////////////////////////////////////////////////////////// ERC165 LOGIC //////////////////////////////////////////////////////////////*/ function supportsInterface(bytes4 interfaceId) external pure returns (bool) { return interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165 interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721 interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata } /*////////////////////////////////////////////////////////////// INTERNAL MINT LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 id) internal { // Does not check the token has not been already minted // or is being minted to address(0) because ids in Pages.sol // are set using a monotonically increasing counter and only // minted to safe addresses or msg.sender who cannot be zero. // Counter overflow is incredibly unrealistic. unchecked { _balanceOf[to]++; } _ownerOf[id] = to; emit Transfer(address(0), to, id); } function _batchMint( address to, uint256 amount, uint256 lastMintedId ) internal returns (uint256) { // Doesn't check if the tokens were already minted or the recipient is address(0) // because Pages.sol manages its ids in a way that it ensures it won't double // mint and will only mint to safe addresses or msg.sender who cannot be zero. unchecked { _balanceOf[to] += amount; for (uint256 i = 0; i < amount; ++i) { _ownerOf[++lastMintedId] = to; emit Transfer(address(0), to, lastMintedId); } } return lastMintedId; } }
{ "remappings": [ "VRGDAs/=lib/VRGDAs/src/", "chainlink/=lib/chainlink/contracts/src/", "ds-test/=lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "goo-issuance/=lib/goo-issuance/src/", "solmate/=lib/solmate/src/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "metadata": { "bytecodeHash": "none" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"_mintStart","type":"uint256"},{"internalType":"contract Goo","name":"_goo","type":"address"},{"internalType":"address","name":"_community","type":"address"},{"internalType":"contract ArtGobblers","name":"_artGobblers","type":"address"},{"internalType":"string","name":"_baseUri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"currentPrice","type":"uint256"}],"name":"PriceExceededMax","type":"error"},{"inputs":[],"name":"ReserveImbalance","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lastMintedPageId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"numPages","type":"uint256"}],"name":"CommunityPagesMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pageId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"}],"name":"PagePurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BASE_URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"artGobblers","outputs":[{"internalType":"contract ArtGobblers","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"community","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentId","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"sold","type":"int256"}],"name":"getTargetSaleTime","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"timeSinceStart","type":"int256"},{"internalType":"uint256","name":"sold","type":"uint256"}],"name":"getVRGDAPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goo","outputs":[{"internalType":"contract Goo","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"isApproved","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numPages","type":"uint256"}],"name":"mintCommunityPages","outputs":[{"internalType":"uint256","name":"lastMintedPageId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxPrice","type":"uint256"},{"internalType":"bool","name":"useVirtualBalance","type":"bool"}],"name":"mintFromGoo","outputs":[{"internalType":"uint256","name":"pageId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numMintedForCommunity","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pagePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"targetPrice","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pageId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000000000063602df0000000000000000000000000600000000a36f3cd48407e35eb7c5c910dc1f7a8000000000000000000000000df2aaeead21cf2bff3965e858332ac8c8364e99100000000000000000000000060bb1e2aa1c9acafb4d34f71585d7e959f38776900000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002768747470733a2f2f6e6674732e617274676f62626c6572732e636f6d2f6170692f70616765732f00000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _mintStart (uint256): 1667247600
Arg [1] : _goo (address): 0x600000000a36F3cD48407e35eB7C5c910dc1f7a8
Arg [2] : _community (address): 0xDf2aAeead21Cf2BFF3965E858332aC8c8364E991
Arg [3] : _artGobblers (address): 0x60bb1e2AA1c9ACAfB4d34F71585D7e959f387769
Arg [4] : _baseUri (string): https://nfts.artgobblers.com/api/pages/
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000063602df0
Arg [1] : 000000000000000000000000600000000a36f3cd48407e35eb7c5c910dc1f7a8
Arg [2] : 000000000000000000000000df2aaeead21cf2bff3965e858332ac8c8364e991
Arg [3] : 00000000000000000000000060bb1e2aa1c9acafb4d34f71585d7e959f387769
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000027
Arg [6] : 68747470733a2f2f6e6674732e617274676f62626c6572732e636f6d2f617069
Arg [7] : 2f70616765732f00000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.